Color Management, Stage 2: Switch color pipeline to use OpenColorIO
[blender.git] / source / blender / editors / render / render_internal.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008 Blender Foundation.
19  * All rights reserved.
20  *
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/render/render_internal.c
26  *  \ingroup edrend
27  */
28
29
30 #include <math.h>
31 #include <string.h>
32 #include <stddef.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_blenlib.h"
37 #include "BLI_math.h"
38 #include "BLI_threads.h"
39 #include "BLI_rand.h"
40 #include "BLI_utildefines.h"
41
42 #include "DNA_scene_types.h"
43
44 #include "BKE_blender.h"
45 #include "BKE_context.h"
46 #include "BKE_global.h"
47 #include "BKE_image.h"
48 #include "BKE_library.h"
49 #include "BKE_main.h"
50 #include "BKE_node.h"
51 #include "BKE_multires.h"
52 #include "BKE_report.h"
53 #include "BKE_sequencer.h"
54 #include "BKE_screen.h"
55 #include "BKE_scene.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "ED_screen.h"
61 #include "ED_object.h"
62
63 #include "RE_pipeline.h"
64 #include "IMB_colormanagement.h"
65 #include "IMB_imbuf.h"
66 #include "IMB_imbuf_types.h"
67
68 #include "RNA_access.h"
69 #include "RNA_define.h"
70
71 #include "wm_window.h"
72
73 #include "render_intern.h"
74
75 /* Render Callbacks */
76
77 /* called inside thread! */
78 void image_buffer_rect_update(Scene *scene, RenderResult *rr, ImBuf *ibuf, volatile rcti *renrect)
79 {
80         float *rectf = NULL;
81         int ymin, ymax, xmin, xmax;
82         int rymin, rxmin;
83         unsigned char *rectc;
84
85         /* if renrect argument, we only refresh scanlines */
86         if (renrect) {
87                 /* if ymax==recty, rendering of layer is ready, we should not draw, other things happen... */
88                 if (rr->renlay == NULL || renrect->ymax >= rr->recty)
89                         return;
90
91                 /* xmin here is first subrect x coord, xmax defines subrect width */
92                 xmin = renrect->xmin + rr->crop;
93                 xmax = renrect->xmax - xmin + rr->crop;
94                 if (xmax < 2)
95                         return;
96
97                 ymin = renrect->ymin + rr->crop;
98                 ymax = renrect->ymax - ymin + rr->crop;
99                 if (ymax < 2)
100                         return;
101                 renrect->ymin = renrect->ymax;
102
103         }
104         else {
105                 xmin = ymin = rr->crop;
106                 xmax = rr->rectx - 2 * rr->crop;
107                 ymax = rr->recty - 2 * rr->crop;
108         }
109
110         /* xmin ymin is in tile coords. transform to ibuf */
111         rxmin = rr->tilerect.xmin + xmin;
112         if (rxmin >= ibuf->x) return;
113         rymin = rr->tilerect.ymin + ymin;
114         if (rymin >= ibuf->y) return;
115
116         if (rxmin + xmax > ibuf->x)
117                 xmax = ibuf->x - rxmin;
118         if (rymin + ymax > ibuf->y)
119                 ymax = ibuf->y - rymin;
120
121         if (xmax < 1 || ymax < 1) return;
122
123         /* find current float rect for display, first case is after composite... still weak */
124         if (rr->rectf)
125                 rectf = rr->rectf;
126         else {
127                 if (rr->rect32)
128                         return;
129                 else {
130                         if (rr->renlay == NULL || rr->renlay->rectf == NULL) return;
131                         rectf = rr->renlay->rectf;
132                 }
133         }
134         if (rectf == NULL) return;
135
136         if (ibuf->rect == NULL)
137                 imb_addrectImBuf(ibuf);
138         
139         rectf += 4 * (rr->rectx * ymin + xmin);
140         rectc = (unsigned char *)(ibuf->rect + ibuf->x * rymin + rxmin);
141
142         IMB_partial_display_buffer_update(ibuf, rectf, NULL, rr->rectx, rxmin, rymin,
143                                           &scene->view_settings, &scene->display_settings,
144                                           rxmin, rymin, rxmin + xmax, rymin + ymax);
145 }
146
147 /* ****************************** render invoking ***************** */
148
149 /* set callbacks, exported to sequence render too.
150  * Only call in foreground (UI) renders. */
151
152 static void screen_render_scene_layer_set(wmOperator *op, Main *mainp, Scene **scene, SceneRenderLayer **srl)
153 {
154         /* single layer re-render */
155         if (RNA_struct_property_is_set(op->ptr, "scene")) {
156                 Scene *scn;
157                 char scene_name[MAX_ID_NAME - 2];
158
159                 RNA_string_get(op->ptr, "scene", scene_name);
160                 scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);
161                 
162                 if (scn) {
163                         /* camera switch wont have updated */
164                         scn->r.cfra = (*scene)->r.cfra;
165                         BKE_scene_camera_switch_update(scn);
166
167                         *scene = scn;
168                 }
169         }
170
171         if (RNA_struct_property_is_set(op->ptr, "layer")) {
172                 SceneRenderLayer *rl;
173                 char rl_name[RE_MAXNAME];
174
175                 RNA_string_get(op->ptr, "layer", rl_name);
176                 rl = (SceneRenderLayer *)BLI_findstring(&(*scene)->r.layers, rl_name, offsetof(SceneRenderLayer, name));
177                 
178                 if (rl)
179                         *srl = rl;
180         }
181 }
182
183 /* executes blocking render */
184 static int screen_render_exec(bContext *C, wmOperator *op)
185 {
186         Scene *scene = CTX_data_scene(C);
187         SceneRenderLayer *srl = NULL;
188         Render *re;
189         Image *ima;
190         View3D *v3d = CTX_wm_view3d(C);
191         Main *mainp = CTX_data_main(C);
192         unsigned int lay;
193         const short is_animation = RNA_boolean_get(op->ptr, "animation");
194         const short is_write_still = RNA_boolean_get(op->ptr, "write_still");
195         struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
196
197         /* custom scene and single layer re-render */
198         screen_render_scene_layer_set(op, mainp, &scene, &srl);
199
200         if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
201                 BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected");
202                 return OPERATOR_CANCELLED;
203         }
204
205         re = RE_NewRender(scene->id.name);
206         lay = (v3d) ? v3d->lay : scene->lay;
207
208         G.is_break = FALSE;
209         RE_test_break_cb(re, NULL, (int (*)(void *))blender_test_break);
210
211         ima = BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
212         BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
213         BKE_image_backup_render(scene, ima);
214
215         /* cleanup sequencer caches before starting user triggered render.
216          * otherwise, invalidated cache entries can make their way into
217          * the output rendering. We can't put that into RE_BlenderFrame,
218          * since sequence rendering can call that recursively... (peter) */
219         BKE_sequencer_cache_cleanup();
220
221         RE_SetReports(re, op->reports);
222
223         if (is_animation)
224                 RE_BlenderAnim(re, mainp, scene, camera_override, lay, scene->r.sfra, scene->r.efra, scene->r.frame_step);
225         else
226                 RE_BlenderFrame(re, mainp, scene, srl, camera_override, lay, scene->r.cfra, is_write_still);
227
228         RE_SetReports(re, NULL);
229
230         // no redraw needed, we leave state as we entered it
231         ED_update_for_newframe(mainp, scene, 1);
232
233         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
234
235         return OPERATOR_FINISHED;
236 }
237
238 typedef struct RenderJob {
239         Main *main;
240         Scene *scene;
241         Render *re;
242         wmWindow *win;
243         SceneRenderLayer *srl;
244         struct Object *camera_override;
245         int lay;
246         short anim, write_still;
247         Image *image;
248         ImageUser iuser;
249         short *stop;
250         short *do_update;
251         float *progress;
252         ReportList *reports;
253 } RenderJob;
254
255 static void render_freejob(void *rjv)
256 {
257         RenderJob *rj = rjv;
258
259         MEM_freeN(rj);
260 }
261
262 /* str is IMA_MAX_RENDER_TEXT in size */
263 static void make_renderinfo_string(RenderStats *rs, Scene *scene, char *str)
264 {
265         char info_time_str[32]; // used to be extern to header_info.c
266         uintptr_t mem_in_use, mmap_in_use, peak_memory;
267         float megs_used_memory, mmap_used_memory, megs_peak_memory;
268         char *spos = str;
269
270         mem_in_use = MEM_get_memory_in_use();
271         mmap_in_use = MEM_get_mapped_memory_in_use();
272         peak_memory = MEM_get_peak_memory();
273
274         megs_used_memory = (mem_in_use - mmap_in_use) / (1024.0 * 1024.0);
275         mmap_used_memory = (mmap_in_use) / (1024.0 * 1024.0);
276         megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
277
278         if (scene->lay & 0xFF000000)
279                 spos += sprintf(spos, "Localview | ");
280         else if (scene->r.scemode & R_SINGLE_LAYER)
281                 spos += sprintf(spos, "Single Layer | ");
282
283         spos += sprintf(spos, "Frame:%d ", (scene->r.cfra));
284
285         if (rs->statstr) {
286                 spos += sprintf(spos, "| %s ", rs->statstr);
287         }
288         else {
289                 if (rs->totvert) spos += sprintf(spos, "Ve:%d ", rs->totvert);
290                 if (rs->totface) spos += sprintf(spos, "Fa:%d ", rs->totface);
291                 if (rs->tothalo) spos += sprintf(spos, "Ha:%d ", rs->tothalo);
292                 if (rs->totstrand) spos += sprintf(spos, "St:%d ", rs->totstrand);
293                 if (rs->totlamp) spos += sprintf(spos, "La:%d ", rs->totlamp);
294                 spos += sprintf(spos, "Mem:%.2fM (%.2fM, peak %.2fM) ", megs_used_memory, mmap_used_memory, megs_peak_memory);
295
296                 if (rs->curfield)
297                         spos += sprintf(spos, "Field %d ", rs->curfield);
298                 if (rs->curblur)
299                         spos += sprintf(spos, "Blur %d ", rs->curblur);
300         }
301
302         BLI_timestr(rs->lastframetime, info_time_str);
303         spos += sprintf(spos, "Time:%s ", info_time_str);
304
305         if (rs->curfsa)
306                 spos += sprintf(spos, "| Full Sample %d ", rs->curfsa);
307         
308         if (rs->infostr && rs->infostr[0])
309                 spos += sprintf(spos, "| %s ", rs->infostr);
310
311         /* very weak... but 512 characters is quite safe */
312         if (spos >= str + IMA_MAX_RENDER_TEXT)
313                 if (G.debug & G_DEBUG)
314                         printf("WARNING! renderwin text beyond limit\n");
315
316 }
317
318 static void image_renderinfo_cb(void *rjv, RenderStats *rs)
319 {
320         RenderJob *rj = rjv;
321         RenderResult *rr;
322
323         rr = RE_AcquireResultRead(rj->re);
324
325         if (rr) {
326                 /* malloc OK here, stats_draw is not in tile threads */
327                 if (rr->text == NULL)
328                         rr->text = MEM_callocN(IMA_MAX_RENDER_TEXT, "rendertext");
329
330                 make_renderinfo_string(rs, rj->scene, rr->text);
331         }
332
333         RE_ReleaseResult(rj->re);
334
335         /* make jobs timer to send notifier */
336         *(rj->do_update) = TRUE;
337
338 }
339
340 static void render_progress_update(void *rjv, float progress)
341 {
342         RenderJob *rj = rjv;
343         
344         if (rj->progress && *rj->progress != progress) {
345                 *rj->progress = progress;
346
347                 /* make jobs timer to send notifier */
348                 *(rj->do_update) = TRUE;
349         }
350 }
351
352 static void image_rect_update(void *rjv, RenderResult *rr, volatile rcti *renrect)
353 {
354         RenderJob *rj = rjv;
355         Image *ima = rj->image;
356         ImBuf *ibuf;
357         void *lock;
358
359         /* only update if we are displaying the slot being rendered */
360         if (ima->render_slot != ima->last_render_slot)
361                 return;
362
363         ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
364         if (ibuf) {
365                 image_buffer_rect_update(rj->scene, rr, ibuf, renrect);
366
367                 /* make jobs timer to send notifier */
368                 *(rj->do_update) = TRUE;
369         }
370         BKE_image_release_ibuf(ima, lock);
371 }
372
373 static void render_startjob(void *rjv, short *stop, short *do_update, float *progress)
374 {
375         RenderJob *rj = rjv;
376
377         rj->stop = stop;
378         rj->do_update = do_update;
379         rj->progress = progress;
380
381         RE_SetReports(rj->re, rj->reports);
382
383         if (rj->anim)
384                 RE_BlenderAnim(rj->re, rj->main, rj->scene, rj->camera_override, rj->lay, rj->scene->r.sfra, rj->scene->r.efra, rj->scene->r.frame_step);
385         else
386                 RE_BlenderFrame(rj->re, rj->main, rj->scene, rj->srl, rj->camera_override, rj->lay, rj->scene->r.cfra, rj->write_still);
387
388         RE_SetReports(rj->re, NULL);
389 }
390
391 static void render_endjob(void *rjv)
392 {
393         RenderJob *rj = rjv;
394
395         /* this render may be used again by the sequencer without the active 'Render' where the callbacks
396          * would be re-assigned. assign dummy callbacks to avoid referencing freed renderjobs bug [#24508] */
397         RE_InitRenderCB(rj->re);
398
399         if (rj->main != G.main)
400                 free_main(rj->main);
401
402         /* else the frame will not update for the original value */
403         if (!(rj->scene->r.scemode & R_NO_FRAME_UPDATE)) {
404                 /* possible this fails of loading new file while rendering */
405                 if (G.main->wm.first) {
406                         ED_update_for_newframe(G.main, rj->scene, 1);
407                 }
408         }
409         
410         /* XXX above function sets all tags in nodes */
411         ntreeCompositClearTags(rj->scene->nodetree);
412         
413         /* potentially set by caller */
414         rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;
415         
416         if (rj->srl) {
417                 nodeUpdateID(rj->scene->nodetree, &rj->scene->id);
418                 WM_main_add_notifier(NC_NODE | NA_EDITED, rj->scene);
419         }
420         
421         /* XXX render stability hack */
422         G.is_rendering = FALSE;
423         WM_main_add_notifier(NC_WINDOW, NULL);
424 }
425
426 /* called by render, check job 'stop' value or the global */
427 static int render_breakjob(void *rjv)
428 {
429         RenderJob *rj = rjv;
430
431         if (G.is_break)
432                 return 1;
433         if (rj->stop && *(rj->stop))
434                 return 1;
435         return 0;
436 }
437
438 /* runs in thread, no cursor setting here works. careful with notifiers too (malloc conflicts) */
439 /* maybe need a way to get job send notifer? */
440 static void render_drawlock(void *UNUSED(rjv), int lock)
441 {
442         BKE_spacedata_draw_locks(lock);
443         
444 }
445
446 /* catch esc */
447 static int screen_render_modal(bContext *C, wmOperator *op, wmEvent *event)
448 {
449         Scene *scene = (Scene *) op->customdata;
450
451         /* no running blender, remove handler and pass through */
452         if (0 == WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER)) {
453                 return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
454         }
455
456         /* running render */
457         switch (event->type) {
458                 case ESCKEY:
459                         return OPERATOR_RUNNING_MODAL;
460                         break;
461         }
462         return OPERATOR_PASS_THROUGH;
463 }
464
465 /* using context, starts job */
466 static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
467 {
468         /* new render clears all callbacks */
469         Main *mainp;
470         Scene *scene = CTX_data_scene(C);
471         SceneRenderLayer *srl = NULL;
472         View3D *v3d = CTX_wm_view3d(C);
473         Render *re;
474         wmJob *wm_job;
475         RenderJob *rj;
476         Image *ima;
477         int jobflag;
478         const short is_animation = RNA_boolean_get(op->ptr, "animation");
479         const short is_write_still = RNA_boolean_get(op->ptr, "write_still");
480         struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
481         const char *name;
482         
483         /* only one render job at a time */
484         if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER))
485                 return OPERATOR_CANCELLED;
486
487         if (!RE_is_rendering_allowed(scene, camera_override, op->reports)) {
488                 return OPERATOR_CANCELLED;
489         }
490
491         if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
492                 BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected");
493                 return OPERATOR_CANCELLED;
494         }       
495         
496         /* stop all running jobs, currently previews frustrate Render */
497         WM_jobs_stop_all(CTX_wm_manager(C));
498
499         /* get main */
500         if (G.debug_value == 101) {
501                 /* thread-safety experiment, copy main from the undo buffer */
502                 mainp = BKE_undo_get_main(&scene);
503         }
504         else
505                 mainp = CTX_data_main(C);
506
507         /* cancel animation playback */
508         if (ED_screen_animation_playing(CTX_wm_manager(C)))
509                 ED_screen_animation_play(C, 0, 0);
510         
511         /* handle UI stuff */
512         WM_cursor_wait(1);
513
514         /* flush multires changes (for sculpt) */
515         multires_force_render_update(CTX_data_active_object(C));
516
517         /* cleanup sequencer caches before starting user triggered render.
518          * otherwise, invalidated cache entries can make their way into
519          * the output rendering. We can't put that into RE_BlenderFrame,
520          * since sequence rendering can call that recursively... (peter) */
521         BKE_sequencer_cache_cleanup();
522
523         /* get editmode results */
524         ED_object_exit_editmode(C, 0);  /* 0 = does not exit editmode */
525
526         // store spare
527         // get view3d layer, local layer, make this nice api call to render
528         // store spare
529
530         /* ensure at least 1 area shows result */
531         render_view_open(C, event->x, event->y);
532
533         jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;
534         
535         /* custom scene and single layer re-render */
536         screen_render_scene_layer_set(op, mainp, &scene, &srl);
537
538         if (RNA_struct_property_is_set(op->ptr, "layer"))
539                 jobflag |= WM_JOB_SUSPEND;
540
541         /* job custom data */
542         rj = MEM_callocN(sizeof(RenderJob), "render job");
543         rj->main = mainp;
544         rj->scene = scene;
545         rj->win = CTX_wm_window(C);
546         rj->srl = srl;
547         rj->camera_override = camera_override;
548         rj->lay = (v3d) ? v3d->lay : scene->lay;
549         rj->anim = is_animation;
550         rj->write_still = is_write_still && !is_animation;
551         rj->iuser.scene = scene;
552         rj->iuser.ok = 1;
553         rj->reports = op->reports;
554
555         /* setup job */
556         if (RE_seq_render_active(scene, &scene->r)) name = "Sequence Render";
557         else name = "Render";
558
559         wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
560         WM_jobs_customdata_set(wm_job, rj, render_freejob);
561         WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
562         WM_jobs_callbacks(wm_job, render_startjob, NULL, NULL, render_endjob);
563
564         /* get a render result image, and make sure it is empty */
565         ima = BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
566         BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
567         BKE_image_backup_render(rj->scene, ima);
568         rj->image = ima;
569
570         /* setup new render */
571         re = RE_NewRender(scene->id.name);
572         RE_test_break_cb(re, rj, render_breakjob);
573         RE_draw_lock_cb(re, rj, render_drawlock);
574         RE_display_draw_cb(re, rj, image_rect_update);
575         RE_stats_draw_cb(re, rj, image_renderinfo_cb);
576         RE_progress_cb(re, rj, render_progress_update);
577
578         rj->re = re;
579         G.is_break = FALSE;
580
581         /* store actual owner of job, so modal operator could check for it,
582          * the reason of this is that active scene could change when rendering
583          * several layers from compositor [#31800]
584          */
585         op->customdata = scene;
586
587         WM_jobs_start(CTX_wm_manager(C), wm_job);
588
589         WM_cursor_wait(0);
590         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
591
592         /* we set G.is_rendering here already instead of only in the job, this ensure
593          * main loop or other scene updates are disabled in time, since they may
594          * have started before the job thread */
595         G.is_rendering = TRUE;
596
597         /* add modal handler for ESC */
598         WM_event_add_modal_handler(C, op);
599
600         return OPERATOR_RUNNING_MODAL;
601 }
602
603 /* contextual render, using current scene, view3d? */
604 void RENDER_OT_render(wmOperatorType *ot)
605 {
606         /* identifiers */
607         ot->name = "Render";
608         ot->description = "Render active scene";
609         ot->idname = "RENDER_OT_render";
610
611         /* api callbacks */
612         ot->invoke = screen_render_invoke;
613         ot->modal = screen_render_modal;
614         ot->exec = screen_render_exec;
615
616         /*ot->poll = ED_operator_screenactive;*/ /* this isn't needed, causes failer in background mode */
617
618         RNA_def_boolean(ot->srna, "animation", 0, "Animation", "Render files from the animation range of this scene");
619         RNA_def_boolean(ot->srna, "write_still", 0, "Write Image", "Save rendered the image to the output path (used only when animation is disabled)");
620         RNA_def_string(ot->srna, "layer", "", RE_MAXNAME, "Render Layer", "Single render layer to re-render (used only when animation is disabled)");
621         RNA_def_string(ot->srna, "scene", "", MAX_ID_NAME - 2, "Scene", "Scene to render, current scene if not specified");
622 }
623