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