Cleanup: outliner range selection
[blender.git] / source / blender / render / intern / source / render_result.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) 2006 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup render
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28
29 #include "MEM_guardedalloc.h"
30
31 #include "BLI_utildefines.h"
32 #include "BLI_ghash.h"
33 #include "BLI_listbase.h"
34 #include "BLI_hash_md5.h"
35 #include "BLI_path_util.h"
36 #include "BLI_rect.h"
37 #include "BLI_string.h"
38 #include "BLI_threads.h"
39
40 #include "BKE_appdir.h"
41 #include "BKE_camera.h"
42 #include "BKE_global.h"
43 #include "BKE_image.h"
44 #include "BKE_report.h"
45 #include "BKE_scene.h"
46
47 #include "IMB_imbuf.h"
48 #include "IMB_imbuf_types.h"
49 #include "IMB_colormanagement.h"
50
51 #include "intern/openexr/openexr_multi.h"
52
53 #include "RE_engine.h"
54
55 #include "render_result.h"
56 #include "render_types.h"
57
58 /********************************** Free *************************************/
59
60 static void render_result_views_free(RenderResult *res)
61 {
62   while (res->views.first) {
63     RenderView *rv = res->views.first;
64     BLI_remlink(&res->views, rv);
65
66     if (rv->rect32) {
67       MEM_freeN(rv->rect32);
68     }
69
70     if (rv->rectz) {
71       MEM_freeN(rv->rectz);
72     }
73
74     if (rv->rectf) {
75       MEM_freeN(rv->rectf);
76     }
77
78     MEM_freeN(rv);
79   }
80
81   res->have_combined = false;
82 }
83
84 void render_result_free(RenderResult *res)
85 {
86   if (res == NULL) {
87     return;
88   }
89
90   while (res->layers.first) {
91     RenderLayer *rl = res->layers.first;
92
93     while (rl->passes.first) {
94       RenderPass *rpass = rl->passes.first;
95       if (rpass->rect) {
96         MEM_freeN(rpass->rect);
97       }
98       BLI_remlink(&rl->passes, rpass);
99       MEM_freeN(rpass);
100     }
101     BLI_remlink(&res->layers, rl);
102     MEM_freeN(rl);
103   }
104
105   render_result_views_free(res);
106
107   if (res->rect32) {
108     MEM_freeN(res->rect32);
109   }
110   if (res->rectz) {
111     MEM_freeN(res->rectz);
112   }
113   if (res->rectf) {
114     MEM_freeN(res->rectf);
115   }
116   if (res->text) {
117     MEM_freeN(res->text);
118   }
119   if (res->error) {
120     MEM_freeN(res->error);
121   }
122
123   BKE_stamp_data_free(res->stamp_data);
124
125   MEM_freeN(res);
126 }
127
128 /* version that's compatible with fullsample buffers */
129 void render_result_free_list(ListBase *lb, RenderResult *rr)
130 {
131   RenderResult *rrnext;
132
133   for (; rr; rr = rrnext) {
134     rrnext = rr->next;
135
136     if (lb && lb->first) {
137       BLI_remlink(lb, rr);
138     }
139
140     render_result_free(rr);
141   }
142 }
143
144 /********************************* multiview *************************************/
145
146 /* create a new views Listbase in rr without duplicating the memory pointers */
147 void render_result_views_shallowcopy(RenderResult *dst, RenderResult *src)
148 {
149   RenderView *rview;
150
151   if (dst == NULL || src == NULL) {
152     return;
153   }
154
155   for (rview = src->views.first; rview; rview = rview->next) {
156     RenderView *rv;
157
158     rv = MEM_mallocN(sizeof(RenderView), "new render view");
159     BLI_addtail(&dst->views, rv);
160
161     BLI_strncpy(rv->name, rview->name, sizeof(rv->name));
162     rv->rectf = rview->rectf;
163     rv->rectz = rview->rectz;
164     rv->rect32 = rview->rect32;
165   }
166 }
167
168 /* free the views created temporarily */
169 void render_result_views_shallowdelete(RenderResult *rr)
170 {
171   if (rr == NULL) {
172     return;
173   }
174
175   while (rr->views.first) {
176     RenderView *rv = rr->views.first;
177     BLI_remlink(&rr->views, rv);
178     MEM_freeN(rv);
179   }
180 }
181
182 static char *set_pass_name(char *outname, const char *name, int channel, const char *chan_id)
183 {
184   BLI_strncpy(outname, name, EXR_PASS_MAXNAME);
185   if (channel >= 0) {
186     char token[3] = {'.', chan_id[channel], '\0'};
187     strncat(outname, token, EXR_PASS_MAXNAME);
188   }
189   return outname;
190 }
191
192 static void set_pass_full_name(
193     char *fullname, const char *name, int channel, const char *view, const char *chan_id)
194 {
195   BLI_strncpy(fullname, name, EXR_PASS_MAXNAME);
196   if (view && view[0]) {
197     strncat(fullname, ".", EXR_PASS_MAXNAME);
198     strncat(fullname, view, EXR_PASS_MAXNAME);
199   }
200   if (channel >= 0) {
201     char token[3] = {'.', chan_id[channel], '\0'};
202     strncat(fullname, token, EXR_PASS_MAXNAME);
203   }
204 }
205
206 /********************************** New **************************************/
207
208 static RenderPass *render_layer_add_pass(RenderResult *rr,
209                                          RenderLayer *rl,
210                                          int channels,
211                                          const char *name,
212                                          const char *viewname,
213                                          const char *chan_id)
214 {
215   const int view_id = BLI_findstringindex(&rr->views, viewname, offsetof(RenderView, name));
216   RenderPass *rpass = MEM_callocN(sizeof(RenderPass), name);
217   size_t rectsize = ((size_t)rr->rectx) * rr->recty * channels;
218
219   rpass->channels = channels;
220   rpass->rectx = rl->rectx;
221   rpass->recty = rl->recty;
222   rpass->view_id = view_id;
223
224   BLI_strncpy(rpass->name, name, sizeof(rpass->name));
225   BLI_strncpy(rpass->chan_id, chan_id, sizeof(rpass->chan_id));
226   BLI_strncpy(rpass->view, viewname, sizeof(rpass->view));
227   set_pass_full_name(rpass->fullname, rpass->name, -1, rpass->view, rpass->chan_id);
228
229   if (rl->exrhandle) {
230     int a;
231     for (a = 0; a < channels; a++) {
232       char passname[EXR_PASS_MAXNAME];
233       IMB_exr_add_channel(rl->exrhandle,
234                           rl->name,
235                           set_pass_name(passname, rpass->name, a, rpass->chan_id),
236                           viewname,
237                           0,
238                           0,
239                           NULL,
240                           false);
241     }
242   }
243
244   /* Always allocate combined for display, in case of save buffers
245    * other passes are not allocated and only saved to the EXR file. */
246   if (rl->exrhandle == NULL || STREQ(rpass->name, RE_PASSNAME_COMBINED)) {
247     float *rect;
248     int x;
249
250     rpass->rect = MEM_mapallocN(sizeof(float) * rectsize, name);
251     if (rpass->rect == NULL) {
252       MEM_freeN(rpass);
253       return NULL;
254     }
255
256     if (STREQ(rpass->name, RE_PASSNAME_VECTOR)) {
257       /* initialize to max speed */
258       rect = rpass->rect;
259       for (x = rectsize - 1; x >= 0; x--) {
260         rect[x] = PASS_VECTOR_MAX;
261       }
262     }
263     else if (STREQ(rpass->name, RE_PASSNAME_Z)) {
264       rect = rpass->rect;
265       for (x = rectsize - 1; x >= 0; x--) {
266         rect[x] = 10e10;
267       }
268     }
269   }
270
271   BLI_addtail(&rl->passes, rpass);
272
273   return rpass;
274 }
275 /* wrapper called from render_opengl */
276 RenderPass *gp_add_pass(
277     RenderResult *rr, RenderLayer *rl, int channels, const char *name, const char *viewname)
278 {
279   return render_layer_add_pass(rr, rl, channels, name, viewname, "RGBA");
280 }
281
282 /* called by main render as well for parts */
283 /* will read info from Render *re to define layers */
284 /* called in threads */
285 /* re->winx,winy is coordinate space of entire image, partrct the part within */
286 RenderResult *render_result_new(Render *re,
287                                 rcti *partrct,
288                                 int crop,
289                                 int savebuffers,
290                                 const char *layername,
291                                 const char *viewname)
292 {
293   RenderResult *rr;
294   RenderLayer *rl;
295   RenderView *rv;
296   int rectx, recty;
297
298   rectx = BLI_rcti_size_x(partrct);
299   recty = BLI_rcti_size_y(partrct);
300
301   if (rectx <= 0 || recty <= 0) {
302     return NULL;
303   }
304
305   rr = MEM_callocN(sizeof(RenderResult), "new render result");
306   rr->rectx = rectx;
307   rr->recty = recty;
308   rr->renrect.xmin = 0;
309   rr->renrect.xmax = rectx - 2 * crop;
310   /* crop is one or two extra pixels rendered for filtering, is used for merging and display too */
311   rr->crop = crop;
312
313   /* tilerect is relative coordinates within render disprect. do not subtract crop yet */
314   rr->tilerect.xmin = partrct->xmin - re->disprect.xmin;
315   rr->tilerect.xmax = partrct->xmax - re->disprect.xmin;
316   rr->tilerect.ymin = partrct->ymin - re->disprect.ymin;
317   rr->tilerect.ymax = partrct->ymax - re->disprect.ymin;
318
319   if (savebuffers) {
320     rr->do_exr_tile = true;
321   }
322
323   render_result_views_new(rr, &re->r);
324
325   /* check renderdata for amount of layers */
326   FOREACH_VIEW_LAYER_TO_RENDER_BEGIN (re, view_layer) {
327     if (layername && layername[0]) {
328       if (!STREQ(view_layer->name, layername)) {
329         continue;
330       }
331     }
332
333     rl = MEM_callocN(sizeof(RenderLayer), "new render layer");
334     BLI_addtail(&rr->layers, rl);
335
336     BLI_strncpy(rl->name, view_layer->name, sizeof(rl->name));
337     rl->layflag = view_layer->layflag;
338
339     /* for debugging: view_layer->passflag | SCE_PASS_RAYHITS; */
340     rl->passflag = view_layer->passflag;
341
342     rl->rectx = rectx;
343     rl->recty = recty;
344
345     if (rr->do_exr_tile) {
346       rl->exrhandle = IMB_exr_get_handle();
347     }
348
349     for (rv = rr->views.first; rv; rv = rv->next) {
350       const char *view = rv->name;
351
352       if (viewname && viewname[0]) {
353         if (!STREQ(view, viewname)) {
354           continue;
355         }
356       }
357
358       if (rr->do_exr_tile) {
359         IMB_exr_add_view(rl->exrhandle, view);
360       }
361
362 #define RENDER_LAYER_ADD_PASS_SAFE(rr, rl, channels, name, viewname, chan_id) \
363   do { \
364     if (render_layer_add_pass(rr, rl, channels, name, viewname, chan_id) == NULL) { \
365       render_result_free(rr); \
366       return NULL; \
367     } \
368   } while (false)
369
370       /* a renderlayer should always have a Combined pass*/
371       render_layer_add_pass(rr, rl, 4, "Combined", view, "RGBA");
372
373       if (view_layer->passflag & SCE_PASS_Z) {
374         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_Z, view, "Z");
375       }
376       if (view_layer->passflag & SCE_PASS_VECTOR) {
377         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 4, RE_PASSNAME_VECTOR, view, "XYZW");
378       }
379       if (view_layer->passflag & SCE_PASS_NORMAL) {
380         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_NORMAL, view, "XYZ");
381       }
382       if (view_layer->passflag & SCE_PASS_UV) {
383         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_UV, view, "UVA");
384       }
385       if (view_layer->passflag & SCE_PASS_EMIT) {
386         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_EMIT, view, "RGB");
387       }
388       if (view_layer->passflag & SCE_PASS_AO) {
389         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_AO, view, "RGB");
390       }
391       if (view_layer->passflag & SCE_PASS_ENVIRONMENT) {
392         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_ENVIRONMENT, view, "RGB");
393       }
394       if (view_layer->passflag & SCE_PASS_SHADOW) {
395         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SHADOW, view, "RGB");
396       }
397       if (view_layer->passflag & SCE_PASS_INDEXOB) {
398         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_INDEXOB, view, "X");
399       }
400       if (view_layer->passflag & SCE_PASS_INDEXMA) {
401         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_INDEXMA, view, "X");
402       }
403       if (view_layer->passflag & SCE_PASS_MIST) {
404         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 1, RE_PASSNAME_MIST, view, "Z");
405       }
406       if (rl->passflag & SCE_PASS_RAYHITS) {
407         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 4, RE_PASSNAME_RAYHITS, view, "RGB");
408       }
409       if (view_layer->passflag & SCE_PASS_DIFFUSE_DIRECT) {
410         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_DIFFUSE_DIRECT, view, "RGB");
411       }
412       if (view_layer->passflag & SCE_PASS_DIFFUSE_INDIRECT) {
413         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_DIFFUSE_INDIRECT, view, "RGB");
414       }
415       if (view_layer->passflag & SCE_PASS_DIFFUSE_COLOR) {
416         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_DIFFUSE_COLOR, view, "RGB");
417       }
418       if (view_layer->passflag & SCE_PASS_GLOSSY_DIRECT) {
419         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_GLOSSY_DIRECT, view, "RGB");
420       }
421       if (view_layer->passflag & SCE_PASS_GLOSSY_INDIRECT) {
422         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_GLOSSY_INDIRECT, view, "RGB");
423       }
424       if (view_layer->passflag & SCE_PASS_GLOSSY_COLOR) {
425         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_GLOSSY_COLOR, view, "RGB");
426       }
427       if (view_layer->passflag & SCE_PASS_TRANSM_DIRECT) {
428         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_TRANSM_DIRECT, view, "RGB");
429       }
430       if (view_layer->passflag & SCE_PASS_TRANSM_INDIRECT) {
431         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_TRANSM_INDIRECT, view, "RGB");
432       }
433       if (view_layer->passflag & SCE_PASS_TRANSM_COLOR) {
434         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_TRANSM_COLOR, view, "RGB");
435       }
436       if (view_layer->passflag & SCE_PASS_SUBSURFACE_DIRECT) {
437         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SUBSURFACE_DIRECT, view, "RGB");
438       }
439       if (view_layer->passflag & SCE_PASS_SUBSURFACE_INDIRECT) {
440         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SUBSURFACE_INDIRECT, view, "RGB");
441       }
442       if (view_layer->passflag & SCE_PASS_SUBSURFACE_COLOR) {
443         RENDER_LAYER_ADD_PASS_SAFE(rr, rl, 3, RE_PASSNAME_SUBSURFACE_COLOR, view, "RGB");
444       }
445 #undef RENDER_LAYER_ADD_PASS_SAFE
446     }
447   }
448   FOREACH_VIEW_LAYER_TO_RENDER_END;
449
450   /* previewrender doesn't do layers, so we make a default one */
451   if (BLI_listbase_is_empty(&rr->layers) && !(layername && layername[0])) {
452     rl = MEM_callocN(sizeof(RenderLayer), "new render layer");
453     BLI_addtail(&rr->layers, rl);
454
455     rl->rectx = rectx;
456     rl->recty = recty;
457
458     /* duplicate code... */
459     if (rr->do_exr_tile) {
460       rl->exrhandle = IMB_exr_get_handle();
461     }
462
463     for (rv = rr->views.first; rv; rv = rv->next) {
464       const char *view = rv->name;
465
466       if (viewname && viewname[0]) {
467         if (strcmp(view, viewname) != 0) {
468           continue;
469         }
470       }
471
472       if (rr->do_exr_tile) {
473         IMB_exr_add_view(rl->exrhandle, view);
474       }
475
476       /* a renderlayer should always have a Combined pass */
477       render_layer_add_pass(rr, rl, 4, RE_PASSNAME_COMBINED, view, "RGBA");
478     }
479
480     /* note, this has to be in sync with scene.c */
481     rl->layflag = 0x7FFF; /* solid ztra halo strand */
482     rl->passflag = SCE_PASS_COMBINED;
483
484     re->active_view_layer = 0;
485   }
486
487   /* border render; calculate offset for use in compositor. compo is centralized coords */
488   /* XXX obsolete? I now use it for drawing border render offset (ton) */
489   rr->xof = re->disprect.xmin + BLI_rcti_cent_x(&re->disprect) - (re->winx / 2);
490   rr->yof = re->disprect.ymin + BLI_rcti_cent_y(&re->disprect) - (re->winy / 2);
491
492   return rr;
493 }
494
495 void render_result_clone_passes(Render *re, RenderResult *rr, const char *viewname)
496 {
497   RenderLayer *rl;
498   RenderPass *main_rp;
499
500   for (rl = rr->layers.first; rl; rl = rl->next) {
501     RenderLayer *main_rl = BLI_findstring(
502         &re->result->layers, rl->name, offsetof(RenderLayer, name));
503     if (!main_rl) {
504       continue;
505     }
506
507     for (main_rp = main_rl->passes.first; main_rp; main_rp = main_rp->next) {
508       if (viewname && viewname[0] && !STREQ(main_rp->view, viewname)) {
509         continue;
510       }
511
512       /* Compare fullname to make sure that the view also is equal. */
513       RenderPass *rp = BLI_findstring(
514           &rl->passes, main_rp->fullname, offsetof(RenderPass, fullname));
515       if (!rp) {
516         render_layer_add_pass(
517             rr, rl, main_rp->channels, main_rp->name, main_rp->view, main_rp->chan_id);
518       }
519     }
520   }
521 }
522
523 void render_result_add_pass(RenderResult *rr,
524                             const char *name,
525                             int channels,
526                             const char *chan_id,
527                             const char *layername,
528                             const char *viewname)
529 {
530   RenderLayer *rl;
531   RenderPass *rp;
532   RenderView *rv;
533
534   for (rl = rr->layers.first; rl; rl = rl->next) {
535     if (layername && layername[0] && !STREQ(rl->name, layername)) {
536       continue;
537     }
538
539     for (rv = rr->views.first; rv; rv = rv->next) {
540       const char *view = rv->name;
541
542       if (viewname && viewname[0] && !STREQ(view, viewname)) {
543         continue;
544       }
545
546       /* Ensure that the pass doesn't exist yet. */
547       for (rp = rl->passes.first; rp; rp = rp->next) {
548         if (!STREQ(rp->name, name)) {
549           continue;
550         }
551         if (!STREQ(rp->view, view)) {
552           continue;
553         }
554         break;
555       }
556
557       if (!rp) {
558         render_layer_add_pass(rr, rl, channels, name, view, chan_id);
559       }
560     }
561   }
562 }
563
564 static int passtype_from_name(const char *name)
565 {
566   const char delim[] = {'.', '\0'};
567   const char *sep, *suf;
568   int len = BLI_str_partition(name, delim, &sep, &suf);
569
570 #define CHECK_PASS(NAME) \
571   if (STREQLEN(name, RE_PASSNAME_##NAME, len)) \
572   return SCE_PASS_##NAME
573
574   CHECK_PASS(COMBINED);
575   CHECK_PASS(Z);
576   CHECK_PASS(VECTOR);
577   CHECK_PASS(NORMAL);
578   CHECK_PASS(UV);
579   CHECK_PASS(EMIT);
580   CHECK_PASS(SHADOW);
581   CHECK_PASS(AO);
582   CHECK_PASS(ENVIRONMENT);
583   CHECK_PASS(INDEXOB);
584   CHECK_PASS(INDEXMA);
585   CHECK_PASS(MIST);
586   CHECK_PASS(RAYHITS);
587   CHECK_PASS(DIFFUSE_DIRECT);
588   CHECK_PASS(DIFFUSE_INDIRECT);
589   CHECK_PASS(DIFFUSE_COLOR);
590   CHECK_PASS(GLOSSY_DIRECT);
591   CHECK_PASS(GLOSSY_INDIRECT);
592   CHECK_PASS(GLOSSY_COLOR);
593   CHECK_PASS(TRANSM_DIRECT);
594   CHECK_PASS(TRANSM_INDIRECT);
595   CHECK_PASS(TRANSM_COLOR);
596   CHECK_PASS(SUBSURFACE_DIRECT);
597   CHECK_PASS(SUBSURFACE_INDIRECT);
598   CHECK_PASS(SUBSURFACE_COLOR);
599
600 #undef CHECK_PASS
601   return 0;
602 }
603
604 /* callbacks for render_result_new_from_exr */
605 static void *ml_addlayer_cb(void *base, const char *str)
606 {
607   RenderResult *rr = base;
608   RenderLayer *rl;
609
610   rl = MEM_callocN(sizeof(RenderLayer), "new render layer");
611   BLI_addtail(&rr->layers, rl);
612
613   BLI_strncpy(rl->name, str, EXR_LAY_MAXNAME);
614   return rl;
615 }
616
617 static void ml_addpass_cb(void *base,
618                           void *lay,
619                           const char *name,
620                           float *rect,
621                           int totchan,
622                           const char *chan_id,
623                           const char *view)
624 {
625   RenderResult *rr = base;
626   RenderLayer *rl = lay;
627   RenderPass *rpass = MEM_callocN(sizeof(RenderPass), "loaded pass");
628
629   BLI_addtail(&rl->passes, rpass);
630   rpass->channels = totchan;
631   rl->passflag |= passtype_from_name(name);
632
633   /* channel id chars */
634   BLI_strncpy(rpass->chan_id, chan_id, sizeof(rpass->chan_id));
635
636   rpass->rect = rect;
637   BLI_strncpy(rpass->name, name, EXR_PASS_MAXNAME);
638   BLI_strncpy(rpass->view, view, sizeof(rpass->view));
639   set_pass_full_name(rpass->fullname, name, -1, view, rpass->chan_id);
640
641   if (view[0] != '\0') {
642     rpass->view_id = BLI_findstringindex(&rr->views, view, offsetof(RenderView, name));
643   }
644   else {
645     rpass->view_id = 0;
646   }
647 }
648
649 static void *ml_addview_cb(void *base, const char *str)
650 {
651   RenderResult *rr = base;
652   RenderView *rv;
653
654   rv = MEM_callocN(sizeof(RenderView), "new render view");
655   BLI_strncpy(rv->name, str, EXR_VIEW_MAXNAME);
656
657   /* For stereo drawing we need to ensure:
658    * STEREO_LEFT_NAME  == STEREO_LEFT_ID and
659    * STEREO_RIGHT_NAME == STEREO_RIGHT_ID */
660
661   if (STREQ(str, STEREO_LEFT_NAME)) {
662     BLI_addhead(&rr->views, rv);
663   }
664   else if (STREQ(str, STEREO_RIGHT_NAME)) {
665     RenderView *left_rv = BLI_findstring(&rr->views, STEREO_LEFT_NAME, offsetof(RenderView, name));
666
667     if (left_rv == NULL) {
668       BLI_addhead(&rr->views, rv);
669     }
670     else {
671       BLI_insertlinkafter(&rr->views, left_rv, rv);
672     }
673   }
674   else {
675     BLI_addtail(&rr->views, rv);
676   }
677
678   return rv;
679 }
680
681 static int order_render_passes(const void *a, const void *b)
682 {
683   // 1 if a is after b
684   RenderPass *rpa = (RenderPass *)a;
685   RenderPass *rpb = (RenderPass *)b;
686   unsigned int passtype_a = passtype_from_name(rpa->name);
687   unsigned int passtype_b = passtype_from_name(rpb->name);
688
689   /* Render passes with default type always go first. */
690   if (passtype_b && !passtype_a) {
691     return 1;
692   }
693   if (passtype_a && !passtype_b) {
694     return 0;
695   }
696
697   if (passtype_a && passtype_b) {
698     if (passtype_a > passtype_b) {
699       return 1;
700     }
701     else if (passtype_a < passtype_b) {
702       return 0;
703     }
704   }
705   else {
706     int cmp = strncmp(rpa->name, rpb->name, EXR_PASS_MAXNAME);
707     if (cmp > 0) {
708       return 1;
709     }
710     if (cmp < 0) {
711       return 0;
712     }
713   }
714
715   /* they have the same type */
716   /* left first */
717   if (STREQ(rpa->view, STEREO_LEFT_NAME)) {
718     return 0;
719   }
720   else if (STREQ(rpb->view, STEREO_LEFT_NAME)) {
721     return 1;
722   }
723
724   /* right second */
725   if (STREQ(rpa->view, STEREO_RIGHT_NAME)) {
726     return 0;
727   }
728   else if (STREQ(rpb->view, STEREO_RIGHT_NAME)) {
729     return 1;
730   }
731
732   /* remaining in ascending id order */
733   return (rpa->view_id < rpb->view_id);
734 }
735
736 /* From imbuf, if a handle was returned and
737  * it's not a singlelayer multiview we convert this to render result. */
738 RenderResult *render_result_new_from_exr(
739     void *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
740 {
741   RenderResult *rr = MEM_callocN(sizeof(RenderResult), __func__);
742   RenderLayer *rl;
743   RenderPass *rpass;
744   const char *to_colorspace = IMB_colormanagement_role_colorspace_name_get(
745       COLOR_ROLE_SCENE_LINEAR);
746
747   rr->rectx = rectx;
748   rr->recty = recty;
749
750   IMB_exr_multilayer_convert(exrhandle, rr, ml_addview_cb, ml_addlayer_cb, ml_addpass_cb);
751
752   for (rl = rr->layers.first; rl; rl = rl->next) {
753     rl->rectx = rectx;
754     rl->recty = recty;
755
756     BLI_listbase_sort(&rl->passes, order_render_passes);
757
758     for (rpass = rl->passes.first; rpass; rpass = rpass->next) {
759       rpass->rectx = rectx;
760       rpass->recty = recty;
761
762       if (rpass->channels >= 3) {
763         IMB_colormanagement_transform(rpass->rect,
764                                       rpass->rectx,
765                                       rpass->recty,
766                                       rpass->channels,
767                                       colorspace,
768                                       to_colorspace,
769                                       predivide);
770       }
771     }
772   }
773
774   return rr;
775 }
776
777 void render_result_view_new(RenderResult *rr, const char *viewname)
778 {
779   RenderView *rv = MEM_callocN(sizeof(RenderView), "new render view");
780   BLI_addtail(&rr->views, rv);
781   BLI_strncpy(rv->name, viewname, sizeof(rv->name));
782 }
783
784 void render_result_views_new(RenderResult *rr, RenderData *rd)
785 {
786   SceneRenderView *srv;
787
788   /* clear previously existing views - for sequencer */
789   render_result_views_free(rr);
790
791   /* check renderdata for amount of views */
792   if ((rd->scemode & R_MULTIVIEW)) {
793     for (srv = rd->views.first; srv; srv = srv->next) {
794       if (BKE_scene_multiview_is_render_view_active(rd, srv) == false) {
795         continue;
796       }
797       render_result_view_new(rr, srv->name);
798     }
799   }
800
801   /* we always need at least one view */
802   if (BLI_listbase_count_at_most(&rr->views, 1) == 0) {
803     render_result_view_new(rr, "");
804   }
805 }
806
807 bool render_result_has_views(RenderResult *rr)
808 {
809   RenderView *rv = rr->views.first;
810   return (rv && (rv->next || rv->name[0]));
811 }
812
813 /*********************************** Merge ***********************************/
814
815 static void do_merge_tile(
816     RenderResult *rr, RenderResult *rrpart, float *target, float *tile, int pixsize)
817 {
818   int y, tilex, tiley;
819   size_t ofs, copylen;
820
821   copylen = tilex = rrpart->rectx;
822   tiley = rrpart->recty;
823
824   if (rrpart->crop) { /* filters add pixel extra */
825     tile += pixsize * (rrpart->crop + ((size_t)rrpart->crop) * tilex);
826
827     copylen = tilex - 2 * rrpart->crop;
828     tiley -= 2 * rrpart->crop;
829
830     ofs = (((size_t)rrpart->tilerect.ymin) + rrpart->crop) * rr->rectx +
831           (rrpart->tilerect.xmin + rrpart->crop);
832     target += pixsize * ofs;
833   }
834   else {
835     ofs = (((size_t)rrpart->tilerect.ymin) * rr->rectx + rrpart->tilerect.xmin);
836     target += pixsize * ofs;
837   }
838
839   copylen *= sizeof(float) * pixsize;
840   tilex *= pixsize;
841   ofs = pixsize * rr->rectx;
842
843   for (y = 0; y < tiley; y++) {
844     memcpy(target, tile, copylen);
845     target += ofs;
846     tile += tilex;
847   }
848 }
849
850 /* used when rendering to a full buffer, or when reading the exr part-layer-pass file */
851 /* no test happens here if it fits... we also assume layers are in sync */
852 /* is used within threads */
853 void render_result_merge(RenderResult *rr, RenderResult *rrpart)
854 {
855   RenderLayer *rl, *rlp;
856   RenderPass *rpass, *rpassp;
857
858   for (rl = rr->layers.first; rl; rl = rl->next) {
859     rlp = RE_GetRenderLayer(rrpart, rl->name);
860     if (rlp) {
861       /* Passes are allocated in sync. */
862       for (rpass = rl->passes.first, rpassp = rlp->passes.first; rpass && rpassp;
863            rpass = rpass->next) {
864         /* For save buffers, skip any passes that are only saved to disk. */
865         if (rpass->rect == NULL || rpassp->rect == NULL) {
866           continue;
867         }
868         /* Renderresult have all passes, renderpart only the active view's passes. */
869         if (strcmp(rpassp->fullname, rpass->fullname) != 0) {
870           continue;
871         }
872
873         do_merge_tile(rr, rrpart, rpass->rect, rpassp->rect, rpass->channels);
874
875         /* manually get next render pass */
876         rpassp = rpassp->next;
877       }
878     }
879   }
880 }
881
882 /* Called from the UI and render pipeline, to save multilayer and multiview
883  * images, optionally isolating a specific, view, layer or RGBA/Z pass. */
884 bool RE_WriteRenderResult(ReportList *reports,
885                           RenderResult *rr,
886                           const char *filename,
887                           ImageFormatData *imf,
888                           const char *view,
889                           int layer)
890 {
891   void *exrhandle = IMB_exr_get_handle();
892   const bool half_float = (imf && imf->depth == R_IMF_CHAN_DEPTH_16);
893   const bool multi_layer = !(imf && imf->imtype == R_IMF_IMTYPE_OPENEXR);
894   const bool write_z = !multi_layer && (imf && (imf->flag & R_IMF_FLAG_ZBUF));
895
896   /* Write first layer if not multilayer and no layer was specified. */
897   if (!multi_layer && layer == -1) {
898     layer = 0;
899   }
900
901   /* First add views since IMB_exr_add_channel checks number of views. */
902   if (render_result_has_views(rr)) {
903     for (RenderView *rview = rr->views.first; rview; rview = rview->next) {
904       if (!view || STREQ(view, rview->name)) {
905         IMB_exr_add_view(exrhandle, rview->name);
906       }
907     }
908   }
909
910   /* Compositing result. */
911   if (rr->have_combined) {
912     for (RenderView *rview = rr->views.first; rview; rview = rview->next) {
913       if (!rview->rectf) {
914         continue;
915       }
916
917       const char *viewname = rview->name;
918       if (view) {
919         if (!STREQ(view, viewname)) {
920           continue;
921         }
922         else {
923           viewname = "";
924         }
925       }
926
927       /* Skip compositing if only a single other layer is requested. */
928       if (!multi_layer && layer != 0) {
929         continue;
930       }
931
932       for (int a = 0; a < 4; a++) {
933         char passname[EXR_PASS_MAXNAME];
934         char layname[EXR_PASS_MAXNAME];
935         const char *chan_id = "RGBA";
936
937         if (multi_layer) {
938           set_pass_name(passname, "Combined", a, chan_id);
939           BLI_strncpy(layname, "Composite", sizeof(layname));
940         }
941         else {
942           passname[0] = chan_id[a];
943           passname[1] = '\0';
944           layname[0] = '\0';
945         }
946
947         IMB_exr_add_channel(exrhandle,
948                             layname,
949                             passname,
950                             viewname,
951                             4,
952                             4 * rr->rectx,
953                             rview->rectf + a,
954                             half_float);
955       }
956
957       if (write_z && rview->rectz) {
958         const char *layname = (multi_layer) ? "Composite" : "";
959         IMB_exr_add_channel(exrhandle, layname, "Z", viewname, 1, rr->rectx, rview->rectz, false);
960       }
961     }
962   }
963
964   /* Other render layers. */
965   int nr = (rr->have_combined) ? 1 : 0;
966   for (RenderLayer *rl = rr->layers.first; rl; rl = rl->next, nr++) {
967     /* Skip other render layers if requested. */
968     if (!multi_layer && nr != layer) {
969       continue;
970     }
971
972     for (RenderPass *rp = rl->passes.first; rp; rp = rp->next) {
973       /* Skip non-RGBA and Z passes if not using multi layer. */
974       if (!multi_layer && !(STREQ(rp->name, RE_PASSNAME_COMBINED) || STREQ(rp->name, "") ||
975                             (STREQ(rp->name, RE_PASSNAME_Z) && write_z))) {
976         continue;
977       }
978
979       /* Skip pass if it does not match the requested view(s). */
980       const char *viewname = rp->view;
981       if (view) {
982         if (!STREQ(view, viewname)) {
983           continue;
984         }
985         else {
986           viewname = "";
987         }
988       }
989
990       /* We only store RGBA passes as half float, for
991        * others precision loss can be problematic. */
992       bool pass_half_float = half_float &&
993                              (STREQ(rp->chan_id, "RGB") || STREQ(rp->chan_id, "RGBA") ||
994                               STREQ(rp->chan_id, "R") || STREQ(rp->chan_id, "G") ||
995                               STREQ(rp->chan_id, "B") || STREQ(rp->chan_id, "A"));
996
997       for (int a = 0; a < rp->channels; a++) {
998         /* Save Combined as RGBA if single layer save. */
999         char passname[EXR_PASS_MAXNAME];
1000         char layname[EXR_PASS_MAXNAME];
1001
1002         if (multi_layer) {
1003           set_pass_name(passname, rp->name, a, rp->chan_id);
1004           BLI_strncpy(layname, rl->name, sizeof(layname));
1005         }
1006         else {
1007           passname[0] = rp->chan_id[a];
1008           passname[1] = '\0';
1009           layname[0] = '\0';
1010         }
1011
1012         IMB_exr_add_channel(exrhandle,
1013                             layname,
1014                             passname,
1015                             viewname,
1016                             rp->channels,
1017                             rp->channels * rr->rectx,
1018                             rp->rect + a,
1019                             pass_half_float);
1020       }
1021     }
1022   }
1023
1024   errno = 0;
1025
1026   BLI_make_existing_file(filename);
1027
1028   int compress = (imf ? imf->exr_codec : 0);
1029   bool success = IMB_exr_begin_write(
1030       exrhandle, filename, rr->rectx, rr->recty, compress, rr->stamp_data);
1031   if (success) {
1032     IMB_exr_write_channels(exrhandle);
1033   }
1034   else {
1035     /* TODO, get the error from openexr's exception */
1036     BKE_reportf(
1037         reports, RPT_ERROR, "Error writing render result, %s (see console)", strerror(errno));
1038   }
1039
1040   IMB_exr_close(exrhandle);
1041   return success;
1042 }
1043
1044 /**************************** Single Layer Rendering *************************/
1045
1046 void render_result_single_layer_begin(Render *re)
1047 {
1048   /* all layers except the active one get temporally pushed away */
1049
1050   /* officially pushed result should be NULL... error can happen with do_seq */
1051   RE_FreeRenderResult(re->pushedresult);
1052
1053   re->pushedresult = re->result;
1054   re->result = NULL;
1055 }
1056
1057 /* if scemode is R_SINGLE_LAYER, at end of rendering, merge the both render results */
1058 void render_result_single_layer_end(Render *re)
1059 {
1060   ViewLayer *view_layer;
1061   RenderLayer *rlpush;
1062   RenderLayer *rl;
1063   int nr;
1064
1065   if (re->result == NULL) {
1066     printf("pop render result error; no current result!\n");
1067     return;
1068   }
1069
1070   if (!re->pushedresult) {
1071     return;
1072   }
1073
1074   if (re->pushedresult->rectx == re->result->rectx &&
1075       re->pushedresult->recty == re->result->recty) {
1076     /* find which layer in re->pushedresult should be replaced */
1077     rl = re->result->layers.first;
1078
1079     /* render result should be empty after this */
1080     BLI_remlink(&re->result->layers, rl);
1081
1082     /* reconstruct render result layers */
1083     for (nr = 0, view_layer = re->view_layers.first; view_layer;
1084          view_layer = view_layer->next, nr++) {
1085       if (nr == re->active_view_layer) {
1086         BLI_addtail(&re->result->layers, rl);
1087       }
1088       else {
1089         rlpush = RE_GetRenderLayer(re->pushedresult, view_layer->name);
1090         if (rlpush) {
1091           BLI_remlink(&re->pushedresult->layers, rlpush);
1092           BLI_addtail(&re->result->layers, rlpush);
1093         }
1094       }
1095     }
1096   }
1097
1098   RE_FreeRenderResult(re->pushedresult);
1099   re->pushedresult = NULL;
1100 }
1101
1102 /************************* EXR Tile File Rendering ***************************/
1103
1104 static void save_render_result_tile(RenderResult *rr, RenderResult *rrpart, const char *viewname)
1105 {
1106   RenderLayer *rlp, *rl;
1107   RenderPass *rpassp;
1108   int offs, partx, party;
1109
1110   BLI_thread_lock(LOCK_IMAGE);
1111
1112   for (rlp = rrpart->layers.first; rlp; rlp = rlp->next) {
1113     rl = RE_GetRenderLayer(rr, rlp->name);
1114
1115     /* should never happen but prevents crash if it does */
1116     BLI_assert(rl);
1117     if (UNLIKELY(rl == NULL)) {
1118       continue;
1119     }
1120
1121     if (rrpart->crop) { /* filters add pixel extra */
1122       offs = (rrpart->crop + rrpart->crop * rrpart->rectx);
1123     }
1124     else {
1125       offs = 0;
1126     }
1127
1128     /* passes are allocated in sync */
1129     for (rpassp = rlp->passes.first; rpassp; rpassp = rpassp->next) {
1130       const int xstride = rpassp->channels;
1131       int a;
1132       char fullname[EXR_PASS_MAXNAME];
1133
1134       for (a = 0; a < xstride; a++) {
1135         set_pass_full_name(fullname, rpassp->name, a, viewname, rpassp->chan_id);
1136
1137         IMB_exr_set_channel(rl->exrhandle,
1138                             rlp->name,
1139                             fullname,
1140                             xstride,
1141                             xstride * rrpart->rectx,
1142                             rpassp->rect + a + xstride * offs);
1143       }
1144     }
1145   }
1146
1147   party = rrpart->tilerect.ymin + rrpart->crop;
1148   partx = rrpart->tilerect.xmin + rrpart->crop;
1149
1150   for (rlp = rrpart->layers.first; rlp; rlp = rlp->next) {
1151     rl = RE_GetRenderLayer(rr, rlp->name);
1152
1153     /* should never happen but prevents crash if it does */
1154     BLI_assert(rl);
1155     if (UNLIKELY(rl == NULL)) {
1156       continue;
1157     }
1158
1159     IMB_exrtile_write_channels(rl->exrhandle, partx, party, 0, viewname, false);
1160   }
1161
1162   BLI_thread_unlock(LOCK_IMAGE);
1163 }
1164
1165 void render_result_save_empty_result_tiles(Render *re)
1166 {
1167   RenderResult *rr;
1168   RenderLayer *rl;
1169
1170   for (rr = re->result; rr; rr = rr->next) {
1171     for (rl = rr->layers.first; rl; rl = rl->next) {
1172       GHashIterator pa_iter;
1173       GHASH_ITER (pa_iter, re->parts) {
1174         RenderPart *pa = BLI_ghashIterator_getValue(&pa_iter);
1175         if (pa->status != PART_STATUS_MERGED) {
1176           int party = pa->disprect.ymin - re->disprect.ymin;
1177           int partx = pa->disprect.xmin - re->disprect.xmin;
1178           IMB_exrtile_write_channels(rl->exrhandle, partx, party, 0, re->viewname, true);
1179         }
1180       }
1181     }
1182   }
1183 }
1184
1185 /* Compute list of passes needed by render engine. */
1186 static void templates_register_pass_cb(void *userdata,
1187                                        Scene *UNUSED(scene),
1188                                        ViewLayer *UNUSED(view_layer),
1189                                        const char *name,
1190                                        int channels,
1191                                        const char *chan_id,
1192                                        int UNUSED(type))
1193 {
1194   ListBase *templates = userdata;
1195   RenderPass *pass = MEM_callocN(sizeof(RenderPass), "RenderPassTemplate");
1196
1197   pass->channels = channels;
1198   BLI_strncpy(pass->name, name, sizeof(pass->name));
1199   BLI_strncpy(pass->chan_id, chan_id, sizeof(pass->chan_id));
1200
1201   BLI_addtail(templates, pass);
1202 }
1203
1204 static void render_result_get_pass_templates(RenderEngine *engine,
1205                                              Render *re,
1206                                              RenderLayer *rl,
1207                                              ListBase *templates)
1208 {
1209   BLI_listbase_clear(templates);
1210
1211   if (engine && engine->type->update_render_passes) {
1212     ViewLayer *view_layer = BLI_findstring(&re->view_layers, rl->name, offsetof(ViewLayer, name));
1213     if (view_layer) {
1214       RE_engine_update_render_passes(
1215           engine, re->scene, view_layer, templates_register_pass_cb, templates);
1216     }
1217   }
1218 }
1219
1220 /* begin write of exr tile file */
1221 void render_result_exr_file_begin(Render *re, RenderEngine *engine)
1222 {
1223   char str[FILE_MAX];
1224
1225   for (RenderResult *rr = re->result; rr; rr = rr->next) {
1226     for (RenderLayer *rl = rr->layers.first; rl; rl = rl->next) {
1227       /* Get passes needed by engine. Normally we would wait for the
1228        * engine to create them, but for EXR file we need to know in
1229        * advance. */
1230       ListBase templates;
1231       render_result_get_pass_templates(engine, re, rl, &templates);
1232
1233       /* Create render passes requested by engine. Only this part is
1234        * mutex locked to avoid deadlock with Python GIL. */
1235       BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1236       for (RenderPass *pass = templates.first; pass; pass = pass->next) {
1237         render_result_add_pass(
1238             re->result, pass->name, pass->channels, pass->chan_id, rl->name, NULL);
1239       }
1240       BLI_rw_mutex_unlock(&re->resultmutex);
1241
1242       BLI_freelistN(&templates);
1243
1244       /* Open EXR file for writing. */
1245       render_result_exr_file_path(re->scene, rl->name, rr->sample_nr, str);
1246       printf("write exr tmp file, %dx%d, %s\n", rr->rectx, rr->recty, str);
1247       IMB_exrtile_begin_write(rl->exrhandle, str, 0, rr->rectx, rr->recty, re->partx, re->party);
1248     }
1249   }
1250 }
1251
1252 /* end write of exr tile file, read back first sample */
1253 void render_result_exr_file_end(Render *re, RenderEngine *engine)
1254 {
1255   /* Close EXR files. */
1256   for (RenderResult *rr = re->result; rr; rr = rr->next) {
1257     for (RenderLayer *rl = rr->layers.first; rl; rl = rl->next) {
1258       IMB_exr_close(rl->exrhandle);
1259       rl->exrhandle = NULL;
1260     }
1261
1262     rr->do_exr_tile = false;
1263   }
1264
1265   /* Create new render result in memory instead of on disk. */
1266   BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1267   render_result_free_list(&re->fullresult, re->result);
1268   re->result = render_result_new(re, &re->disprect, 0, RR_USE_MEM, RR_ALL_LAYERS, RR_ALL_VIEWS);
1269   BLI_rw_mutex_unlock(&re->resultmutex);
1270
1271   for (RenderLayer *rl = re->result->layers.first; rl; rl = rl->next) {
1272     /* Get passes needed by engine. */
1273     ListBase templates;
1274     render_result_get_pass_templates(engine, re, rl, &templates);
1275
1276     /* Create render passes requested by engine. Only this part is
1277      * mutex locked to avoid deadlock with Python GIL. */
1278     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1279     for (RenderPass *pass = templates.first; pass; pass = pass->next) {
1280       render_result_add_pass(
1281           re->result, pass->name, pass->channels, pass->chan_id, rl->name, NULL);
1282     }
1283
1284     BLI_freelistN(&templates);
1285
1286     /* Render passes contents from file. */
1287     char str[FILE_MAXFILE + MAX_ID_NAME + MAX_ID_NAME + 100] = "";
1288     render_result_exr_file_path(re->scene, rl->name, 0, str);
1289     printf("read exr tmp file: %s\n", str);
1290
1291     if (!render_result_exr_file_read_path(re->result, rl, str)) {
1292       printf("cannot read: %s\n", str);
1293     }
1294     BLI_rw_mutex_unlock(&re->resultmutex);
1295   }
1296 }
1297
1298 /* save part into exr file */
1299 void render_result_exr_file_merge(RenderResult *rr, RenderResult *rrpart, const char *viewname)
1300 {
1301   for (; rr && rrpart; rr = rr->next, rrpart = rrpart->next) {
1302     save_render_result_tile(rr, rrpart, viewname);
1303   }
1304 }
1305
1306 /* path to temporary exr file */
1307 void render_result_exr_file_path(Scene *scene, const char *layname, int sample, char *filepath)
1308 {
1309   char name[FILE_MAXFILE + MAX_ID_NAME + MAX_ID_NAME + 100];
1310   const char *fi = BLI_path_basename(BKE_main_blendfile_path_from_global());
1311
1312   if (sample == 0) {
1313     BLI_snprintf(name, sizeof(name), "%s_%s_%s.exr", fi, scene->id.name + 2, layname);
1314   }
1315   else {
1316     BLI_snprintf(name, sizeof(name), "%s_%s_%s%d.exr", fi, scene->id.name + 2, layname, sample);
1317   }
1318
1319   /* Make name safe for paths, see T43275. */
1320   BLI_filename_make_safe(name);
1321
1322   BLI_make_file_string("/", filepath, BKE_tempdir_session(), name);
1323 }
1324
1325 /* called for reading temp files, and for external engines */
1326 int render_result_exr_file_read_path(RenderResult *rr,
1327                                      RenderLayer *rl_single,
1328                                      const char *filepath)
1329 {
1330   RenderLayer *rl;
1331   RenderPass *rpass;
1332   void *exrhandle = IMB_exr_get_handle();
1333   int rectx, recty;
1334
1335   if (IMB_exr_begin_read(exrhandle, filepath, &rectx, &recty) == 0) {
1336     printf("failed being read %s\n", filepath);
1337     IMB_exr_close(exrhandle);
1338     return 0;
1339   }
1340
1341   if (rr == NULL || rectx != rr->rectx || recty != rr->recty) {
1342     if (rr) {
1343       printf("error in reading render result: dimensions don't match\n");
1344     }
1345     else {
1346       printf("error in reading render result: NULL result pointer\n");
1347     }
1348     IMB_exr_close(exrhandle);
1349     return 0;
1350   }
1351
1352   for (rl = rr->layers.first; rl; rl = rl->next) {
1353     if (rl_single && rl_single != rl) {
1354       continue;
1355     }
1356
1357     /* passes are allocated in sync */
1358     for (rpass = rl->passes.first; rpass; rpass = rpass->next) {
1359       const int xstride = rpass->channels;
1360       int a;
1361       char fullname[EXR_PASS_MAXNAME];
1362
1363       for (a = 0; a < xstride; a++) {
1364         set_pass_full_name(fullname, rpass->name, a, rpass->view, rpass->chan_id);
1365         IMB_exr_set_channel(
1366             exrhandle, rl->name, fullname, xstride, xstride * rectx, rpass->rect + a);
1367       }
1368
1369       set_pass_full_name(rpass->fullname, rpass->name, -1, rpass->view, rpass->chan_id);
1370     }
1371   }
1372
1373   IMB_exr_read_channels(exrhandle);
1374   IMB_exr_close(exrhandle);
1375
1376   return 1;
1377 }
1378
1379 static void render_result_exr_file_cache_path(Scene *sce, const char *root, char *r_path)
1380 {
1381   char filename_full[FILE_MAX + MAX_ID_NAME + 100], filename[FILE_MAXFILE], dirname[FILE_MAXDIR];
1382   char path_digest[16] = {0};
1383   char path_hexdigest[33];
1384
1385   /* If root is relative, use either current .blend file dir, or temp one if not saved. */
1386   const char *blendfile_path = BKE_main_blendfile_path_from_global();
1387   if (blendfile_path[0] != '\0') {
1388     BLI_split_dirfile(blendfile_path, dirname, filename, sizeof(dirname), sizeof(filename));
1389     BLI_path_extension_replace(filename, sizeof(filename), ""); /* strip '.blend' */
1390     BLI_hash_md5_buffer(blendfile_path, strlen(blendfile_path), path_digest);
1391   }
1392   else {
1393     BLI_strncpy(dirname, BKE_tempdir_base(), sizeof(dirname));
1394     BLI_strncpy(filename, "UNSAVED", sizeof(filename));
1395   }
1396   BLI_hash_md5_to_hexdigest(path_digest, path_hexdigest);
1397
1398   /* Default to *non-volatile* tmp dir. */
1399   if (*root == '\0') {
1400     root = BKE_tempdir_base();
1401   }
1402
1403   BLI_snprintf(filename_full,
1404                sizeof(filename_full),
1405                "cached_RR_%s_%s_%s.exr",
1406                filename,
1407                sce->id.name + 2,
1408                path_hexdigest);
1409   BLI_make_file_string(dirname, r_path, root, filename_full);
1410 }
1411
1412 void render_result_exr_file_cache_write(Render *re)
1413 {
1414   RenderResult *rr = re->result;
1415   char str[FILE_MAXFILE + FILE_MAXFILE + MAX_ID_NAME + 100];
1416   char *root = U.render_cachedir;
1417
1418   render_result_exr_file_cache_path(re->scene, root, str);
1419   printf("Caching exr file, %dx%d, %s\n", rr->rectx, rr->recty, str);
1420
1421   RE_WriteRenderResult(NULL, rr, str, NULL, NULL, -1);
1422 }
1423
1424 /* For cache, makes exact copy of render result */
1425 bool render_result_exr_file_cache_read(Render *re)
1426 {
1427   char str[FILE_MAXFILE + MAX_ID_NAME + MAX_ID_NAME + 100] = "";
1428   char *root = U.render_cachedir;
1429
1430   RE_FreeRenderResult(re->result);
1431   re->result = render_result_new(re, &re->disprect, 0, RR_USE_MEM, RR_ALL_LAYERS, RR_ALL_VIEWS);
1432
1433   /* First try cache. */
1434   render_result_exr_file_cache_path(re->scene, root, str);
1435
1436   printf("read exr cache file: %s\n", str);
1437   if (!render_result_exr_file_read_path(re->result, NULL, str)) {
1438     printf("cannot read: %s\n", str);
1439     return false;
1440   }
1441   return true;
1442 }
1443
1444 /*************************** Combined Pixel Rect *****************************/
1445
1446 ImBuf *render_result_rect_to_ibuf(RenderResult *rr, RenderData *rd, const int view_id)
1447 {
1448   ImBuf *ibuf = IMB_allocImBuf(rr->rectx, rr->recty, rd->im_format.planes, 0);
1449   RenderView *rv = RE_RenderViewGetById(rr, view_id);
1450
1451   /* if not exists, BKE_imbuf_write makes one */
1452   ibuf->rect = (unsigned int *)rv->rect32;
1453   ibuf->rect_float = rv->rectf;
1454   ibuf->zbuf_float = rv->rectz;
1455
1456   /* float factor for random dither, imbuf takes care of it */
1457   ibuf->dither = rd->dither_intensity;
1458
1459   /* prepare to gamma correct to sRGB color space
1460    * note that sequence editor can generate 8bpc render buffers
1461    */
1462   if (ibuf->rect) {
1463     if (BKE_imtype_valid_depths(rd->im_format.imtype) &
1464         (R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_24 | R_IMF_CHAN_DEPTH_32)) {
1465       if (rd->im_format.depth == R_IMF_CHAN_DEPTH_8) {
1466         /* Higher depth bits are supported but not needed for current file output. */
1467         ibuf->rect_float = NULL;
1468       }
1469       else {
1470         IMB_float_from_rect(ibuf);
1471       }
1472     }
1473     else {
1474       /* ensure no float buffer remained from previous frame */
1475       ibuf->rect_float = NULL;
1476     }
1477   }
1478
1479   /* color -> grayscale */
1480   /* editing directly would alter the render view */
1481   if (rd->im_format.planes == R_IMF_PLANES_BW) {
1482     ImBuf *ibuf_bw = IMB_dupImBuf(ibuf);
1483     IMB_color_to_bw(ibuf_bw);
1484     IMB_freeImBuf(ibuf);
1485     ibuf = ibuf_bw;
1486   }
1487
1488   return ibuf;
1489 }
1490
1491 void RE_render_result_rect_from_ibuf(RenderResult *rr,
1492                                      RenderData *UNUSED(rd),
1493                                      ImBuf *ibuf,
1494                                      const int view_id)
1495 {
1496   RenderView *rv = RE_RenderViewGetById(rr, view_id);
1497
1498   if (ibuf->rect_float) {
1499     rr->have_combined = true;
1500
1501     if (!rv->rectf) {
1502       rv->rectf = MEM_mallocN(4 * sizeof(float) * rr->rectx * rr->recty, "render_seq rectf");
1503     }
1504
1505     memcpy(rv->rectf, ibuf->rect_float, 4 * sizeof(float) * rr->rectx * rr->recty);
1506
1507     /* TSK! Since sequence render doesn't free the *rr render result, the old rect32
1508      * can hang around when sequence render has rendered a 32 bits one before */
1509     MEM_SAFE_FREE(rv->rect32);
1510   }
1511   else if (ibuf->rect) {
1512     rr->have_combined = true;
1513
1514     if (!rv->rect32) {
1515       rv->rect32 = MEM_mallocN(sizeof(int) * rr->rectx * rr->recty, "render_seq rect");
1516     }
1517
1518     memcpy(rv->rect32, ibuf->rect, 4 * rr->rectx * rr->recty);
1519
1520     /* Same things as above, old rectf can hang around from previous render. */
1521     MEM_SAFE_FREE(rv->rectf);
1522   }
1523 }
1524
1525 void render_result_rect_fill_zero(RenderResult *rr, const int view_id)
1526 {
1527   RenderView *rv = RE_RenderViewGetById(rr, view_id);
1528
1529   if (rv->rectf) {
1530     memset(rv->rectf, 0, 4 * sizeof(float) * rr->rectx * rr->recty);
1531   }
1532   else if (rv->rect32) {
1533     memset(rv->rect32, 0, 4 * rr->rectx * rr->recty);
1534   }
1535   else {
1536     rv->rect32 = MEM_callocN(sizeof(int) * rr->rectx * rr->recty, "render_seq rect");
1537   }
1538 }
1539
1540 void render_result_rect_get_pixels(RenderResult *rr,
1541                                    unsigned int *rect,
1542                                    int rectx,
1543                                    int recty,
1544                                    const ColorManagedViewSettings *view_settings,
1545                                    const ColorManagedDisplaySettings *display_settings,
1546                                    const int view_id)
1547 {
1548   RenderView *rv = RE_RenderViewGetById(rr, view_id);
1549
1550   if (rv->rect32) {
1551     memcpy(rect, rv->rect32, sizeof(int) * rr->rectx * rr->recty);
1552   }
1553   else if (rv->rectf) {
1554     IMB_display_buffer_transform_apply((unsigned char *)rect,
1555                                        rv->rectf,
1556                                        rr->rectx,
1557                                        rr->recty,
1558                                        4,
1559                                        view_settings,
1560                                        display_settings,
1561                                        true);
1562   }
1563   else {
1564     /* else fill with black */
1565     memset(rect, 0, sizeof(int) * rectx * recty);
1566   }
1567 }
1568
1569 /*************************** multiview functions *****************************/
1570
1571 bool RE_HasCombinedLayer(RenderResult *res)
1572 {
1573   RenderView *rv;
1574
1575   if (res == NULL) {
1576     return false;
1577   }
1578
1579   rv = res->views.first;
1580   if (rv == NULL) {
1581     return false;
1582   }
1583
1584   return (rv->rect32 || rv->rectf);
1585 }
1586
1587 bool RE_HasFloatPixels(RenderResult *res)
1588 {
1589   RenderView *rview;
1590
1591   for (rview = res->views.first; rview; rview = rview->next) {
1592     if (rview->rect32 && !rview->rectf) {
1593       return false;
1594     }
1595   }
1596
1597   return true;
1598 }
1599
1600 bool RE_RenderResult_is_stereo(RenderResult *res)
1601 {
1602   if (!BLI_findstring(&res->views, STEREO_LEFT_NAME, offsetof(RenderView, name))) {
1603     return false;
1604   }
1605
1606   if (!BLI_findstring(&res->views, STEREO_RIGHT_NAME, offsetof(RenderView, name))) {
1607     return false;
1608   }
1609
1610   return true;
1611 }
1612
1613 RenderView *RE_RenderViewGetById(RenderResult *res, const int view_id)
1614 {
1615   RenderView *rv = BLI_findlink(&res->views, view_id);
1616   BLI_assert(res->views.first);
1617   return rv ? rv : res->views.first;
1618 }
1619
1620 RenderView *RE_RenderViewGetByName(RenderResult *res, const char *viewname)
1621 {
1622   RenderView *rv = BLI_findstring(&res->views, viewname, offsetof(RenderView, name));
1623   BLI_assert(res->views.first);
1624   return rv ? rv : res->views.first;
1625 }
1626
1627 static RenderPass *duplicate_render_pass(RenderPass *rpass)
1628 {
1629   RenderPass *new_rpass = MEM_mallocN(sizeof(RenderPass), "new render pass");
1630   *new_rpass = *rpass;
1631   new_rpass->next = new_rpass->prev = NULL;
1632   if (new_rpass->rect != NULL) {
1633     new_rpass->rect = MEM_dupallocN(new_rpass->rect);
1634   }
1635   return new_rpass;
1636 }
1637
1638 static RenderLayer *duplicate_render_layer(RenderLayer *rl)
1639 {
1640   RenderLayer *new_rl = MEM_mallocN(sizeof(RenderLayer), "new render layer");
1641   *new_rl = *rl;
1642   new_rl->next = new_rl->prev = NULL;
1643   new_rl->passes.first = new_rl->passes.last = NULL;
1644   new_rl->exrhandle = NULL;
1645   for (RenderPass *rpass = rl->passes.first; rpass != NULL; rpass = rpass->next) {
1646     RenderPass *new_rpass = duplicate_render_pass(rpass);
1647     BLI_addtail(&new_rl->passes, new_rpass);
1648   }
1649   return new_rl;
1650 }
1651
1652 static RenderView *duplicate_render_view(RenderView *rview)
1653 {
1654   RenderView *new_rview = MEM_mallocN(sizeof(RenderView), "new render view");
1655   *new_rview = *rview;
1656   if (new_rview->rectf != NULL) {
1657     new_rview->rectf = MEM_dupallocN(new_rview->rectf);
1658   }
1659   if (new_rview->rectz != NULL) {
1660     new_rview->rectz = MEM_dupallocN(new_rview->rectz);
1661   }
1662   if (new_rview->rect32 != NULL) {
1663     new_rview->rect32 = MEM_dupallocN(new_rview->rect32);
1664   }
1665   return new_rview;
1666 }
1667
1668 RenderResult *RE_DuplicateRenderResult(RenderResult *rr)
1669 {
1670   RenderResult *new_rr = MEM_mallocN(sizeof(RenderResult), "new duplicated render result");
1671   *new_rr = *rr;
1672   new_rr->next = new_rr->prev = NULL;
1673   new_rr->layers.first = new_rr->layers.last = NULL;
1674   new_rr->views.first = new_rr->views.last = NULL;
1675   for (RenderLayer *rl = rr->layers.first; rl != NULL; rl = rl->next) {
1676     RenderLayer *new_rl = duplicate_render_layer(rl);
1677     BLI_addtail(&new_rr->layers, new_rl);
1678   }
1679   for (RenderView *rview = rr->views.first; rview != NULL; rview = rview->next) {
1680     RenderView *new_rview = duplicate_render_view(rview);
1681     BLI_addtail(&new_rr->views, new_rview);
1682   }
1683   if (new_rr->rect32 != NULL) {
1684     new_rr->rect32 = MEM_dupallocN(new_rr->rect32);
1685   }
1686   if (new_rr->rectf != NULL) {
1687     new_rr->rectf = MEM_dupallocN(new_rr->rectf);
1688   }
1689   if (new_rr->rectz != NULL) {
1690     new_rr->rectz = MEM_dupallocN(new_rr->rectz);
1691   }
1692   new_rr->stamp_data = BKE_stamp_data_copy(new_rr->stamp_data);
1693   return new_rr;
1694 }