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