Geometry Nodes: new Material input node
[blender.git] / intern / cycles / render / session.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <limits.h>
18 #include <string.h>
19
20 #include "device/device.h"
21 #include "render/bake.h"
22 #include "render/buffers.h"
23 #include "render/camera.h"
24 #include "render/graph.h"
25 #include "render/integrator.h"
26 #include "render/light.h"
27 #include "render/mesh.h"
28 #include "render/object.h"
29 #include "render/scene.h"
30 #include "render/session.h"
31
32 #include "util/util_foreach.h"
33 #include "util/util_function.h"
34 #include "util/util_logging.h"
35 #include "util/util_math.h"
36 #include "util/util_opengl.h"
37 #include "util/util_task.h"
38 #include "util/util_time.h"
39
40 CCL_NAMESPACE_BEGIN
41
42 /* Note about  preserve_tile_device option for tile manager:
43  * progressive refine and viewport rendering does requires tiles to
44  * always be allocated for the same device
45  */
46 Session::Session(const SessionParams &params_)
47     : params(params_),
48       tile_manager(params.progressive,
49                    params.samples,
50                    params.tile_size,
51                    params.start_resolution,
52                    params.background == false || params.progressive_refine,
53                    params.background,
54                    params.tile_order,
55                    max(params.device.multi_devices.size(), 1),
56                    params.pixel_size),
57       stats(),
58       profiler()
59 {
60   device_use_gl = ((params.device.type != DEVICE_CPU) && !params.background);
61
62   TaskScheduler::init(params.threads);
63
64   session_thread = NULL;
65   scene = NULL;
66
67   reset_time = 0.0;
68   last_update_time = 0.0;
69
70   delayed_reset.do_reset = false;
71   delayed_reset.samples = 0;
72
73   display_outdated = false;
74   gpu_draw_ready = false;
75   gpu_need_display_buffer_update = false;
76   pause = false;
77
78   buffers = NULL;
79   display = NULL;
80
81   /* Validate denoising parameters. */
82   set_denoising(params.denoising);
83
84   /* Create CPU/GPU devices. */
85   device = Device::create(params.device, stats, profiler, params.background);
86
87   if (!device->error_message().empty()) {
88     progress.set_error(device->error_message());
89     return;
90   }
91
92   /* Create buffers for interactive rendering. */
93   if (!(params.background && !params.write_render_cb)) {
94     buffers = new RenderBuffers(device);
95     display = new DisplayBuffer(device, params.display_buffer_linear);
96   }
97 }
98
99 Session::~Session()
100 {
101   cancel();
102
103   if (buffers && params.write_render_cb) {
104     /* Copy to display buffer and write out image if requested */
105     delete display;
106
107     display = new DisplayBuffer(device, false);
108     display->reset(buffers->params);
109     copy_to_display_buffer(params.samples);
110
111     int w = display->draw_width;
112     int h = display->draw_height;
113     uchar4 *pixels = display->rgba_byte.copy_from_device(0, w, h);
114     params.write_render_cb((uchar *)pixels, w, h, 4);
115   }
116
117   /* clean up */
118   tile_manager.device_free();
119
120   delete buffers;
121   delete display;
122   delete scene;
123   delete device;
124
125   TaskScheduler::exit();
126 }
127
128 void Session::start()
129 {
130   if (!session_thread) {
131     session_thread = new thread(function_bind(&Session::run, this));
132   }
133 }
134
135 void Session::cancel()
136 {
137   if (session_thread) {
138     /* wait for session thread to end */
139     progress.set_cancel("Exiting");
140
141     gpu_need_display_buffer_update = false;
142     gpu_need_display_buffer_update_cond.notify_all();
143
144     {
145       thread_scoped_lock pause_lock(pause_mutex);
146       pause = false;
147     }
148     pause_cond.notify_all();
149
150     wait();
151   }
152 }
153
154 bool Session::ready_to_reset()
155 {
156   double dt = time_dt() - reset_time;
157
158   if (!display_outdated)
159     return (dt > params.reset_timeout);
160   else
161     return (dt > params.cancel_timeout);
162 }
163
164 /* GPU Session */
165
166 void Session::reset_gpu(BufferParams &buffer_params, int samples)
167 {
168   thread_scoped_lock pause_lock(pause_mutex);
169
170   /* block for buffer access and reset immediately. we can't do this
171    * in the thread, because we need to allocate an OpenGL buffer, and
172    * that only works in the main thread */
173   thread_scoped_lock display_lock(display_mutex);
174   thread_scoped_lock buffers_lock(buffers_mutex);
175
176   display_outdated = true;
177   reset_time = time_dt();
178
179   reset_(buffer_params, samples);
180
181   gpu_need_display_buffer_update = false;
182   gpu_need_display_buffer_update_cond.notify_all();
183
184   pause_cond.notify_all();
185 }
186
187 bool Session::draw_gpu(BufferParams &buffer_params, DeviceDrawParams &draw_params)
188 {
189   /* block for buffer access */
190   thread_scoped_lock display_lock(display_mutex);
191
192   /* first check we already rendered something */
193   if (gpu_draw_ready) {
194     /* then verify the buffers have the expected size, so we don't
195      * draw previous results in a resized window */
196     if (buffer_params.width == display->params.width &&
197         buffer_params.height == display->params.height) {
198       /* for CUDA we need to do tone-mapping still, since we can
199        * only access GL buffers from the main thread. */
200       if (gpu_need_display_buffer_update) {
201         thread_scoped_lock buffers_lock(buffers_mutex);
202         copy_to_display_buffer(tile_manager.state.sample);
203         gpu_need_display_buffer_update = false;
204         gpu_need_display_buffer_update_cond.notify_all();
205       }
206
207       display->draw(device, draw_params);
208
209       if (display_outdated && (time_dt() - reset_time) > params.text_timeout)
210         return false;
211
212       return true;
213     }
214   }
215
216   return false;
217 }
218
219 void Session::run_gpu()
220 {
221   bool tiles_written = false;
222
223   reset_time = time_dt();
224   last_update_time = time_dt();
225   last_display_time = last_update_time;
226
227   progress.set_render_start_time();
228
229   while (!progress.get_cancel()) {
230     /* advance to next tile */
231     bool no_tiles = !tile_manager.next();
232
233     DeviceKernelStatus kernel_state = DEVICE_KERNEL_UNKNOWN;
234     if (no_tiles) {
235       kernel_state = device->get_active_kernel_switch_state();
236     }
237
238     if (params.background) {
239       /* if no work left and in background mode, we can stop immediately */
240       if (no_tiles) {
241         progress.set_status("Finished");
242         break;
243       }
244     }
245
246     /* Don't go in pause mode when image was rendered with preview kernels
247      * When feature kernels become available the session will be reset. */
248     else if (no_tiles && kernel_state == DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL) {
249       time_sleep(0.1);
250     }
251     else if (no_tiles && kernel_state == DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE) {
252       reset_gpu(tile_manager.params, params.samples);
253     }
254
255     else {
256       /* if in interactive mode, and we are either paused or done for now,
257        * wait for pause condition notify to wake up again */
258       thread_scoped_lock pause_lock(pause_mutex);
259
260       if (!pause && !tile_manager.done()) {
261         /* reset could have happened after no_tiles was set, before this lock.
262          * in this case we shall not wait for pause condition
263          */
264       }
265       else if (pause || no_tiles) {
266         update_status_time(pause, no_tiles);
267
268         while (1) {
269           scoped_timer pause_timer;
270           pause_cond.wait(pause_lock);
271           if (pause) {
272             progress.add_skip_time(pause_timer, params.background);
273           }
274
275           update_status_time(pause, no_tiles);
276           progress.set_update();
277
278           if (!pause)
279             break;
280         }
281       }
282
283       if (progress.get_cancel())
284         break;
285     }
286
287     if (!no_tiles) {
288       /* update scene */
289       scoped_timer update_timer;
290       if (update_scene()) {
291         profiler.reset(scene->shaders.size(), scene->objects.size());
292       }
293       progress.add_skip_time(update_timer, params.background);
294
295       if (!device->error_message().empty())
296         progress.set_error(device->error_message());
297
298       if (progress.get_cancel())
299         break;
300
301       /* buffers mutex is locked entirely while rendering each
302        * sample, and released/reacquired on each iteration to allow
303        * reset and draw in between */
304       thread_scoped_lock buffers_lock(buffers_mutex);
305
306       /* update status and timing */
307       update_status_time();
308
309       /* render */
310       bool delayed_denoise = false;
311       const bool need_denoise = render_need_denoise(delayed_denoise);
312       render(need_denoise);
313
314       device->task_wait();
315
316       if (!device->error_message().empty())
317         progress.set_cancel(device->error_message());
318
319       /* update status and timing */
320       update_status_time();
321
322       gpu_need_display_buffer_update = !delayed_denoise;
323       gpu_draw_ready = true;
324       progress.set_update();
325
326       /* wait for until display buffer is updated */
327       if (!params.background) {
328         while (gpu_need_display_buffer_update) {
329           if (progress.get_cancel())
330             break;
331
332           gpu_need_display_buffer_update_cond.wait(buffers_lock);
333         }
334       }
335
336       if (!device->error_message().empty())
337         progress.set_error(device->error_message());
338
339       tiles_written = update_progressive_refine(progress.get_cancel());
340
341       if (progress.get_cancel())
342         break;
343     }
344   }
345
346   if (!tiles_written)
347     update_progressive_refine(true);
348 }
349
350 /* CPU Session */
351
352 void Session::reset_cpu(BufferParams &buffer_params, int samples)
353 {
354   thread_scoped_lock reset_lock(delayed_reset.mutex);
355   thread_scoped_lock pause_lock(pause_mutex);
356
357   display_outdated = true;
358   reset_time = time_dt();
359
360   delayed_reset.params = buffer_params;
361   delayed_reset.samples = samples;
362   delayed_reset.do_reset = true;
363   device->task_cancel();
364
365   pause_cond.notify_all();
366 }
367
368 bool Session::draw_cpu(BufferParams &buffer_params, DeviceDrawParams &draw_params)
369 {
370   thread_scoped_lock display_lock(display_mutex);
371
372   /* first check we already rendered something */
373   if (display->draw_ready()) {
374     /* then verify the buffers have the expected size, so we don't
375      * draw previous results in a resized window */
376     if (buffer_params.width == display->params.width &&
377         buffer_params.height == display->params.height) {
378       display->draw(device, draw_params);
379
380       if (display_outdated && (time_dt() - reset_time) > params.text_timeout)
381         return false;
382
383       return true;
384     }
385   }
386
387   return false;
388 }
389
390 bool Session::steal_tile(RenderTile &rtile, Device *tile_device, thread_scoped_lock &tile_lock)
391 {
392   /* Devices that can get their tiles stolen don't steal tiles themselves.
393    * Additionally, if there are no stealable tiles in flight, give up here. */
394   if (tile_device->info.type == DEVICE_CPU || stealable_tiles == 0) {
395     return false;
396   }
397
398   /* Wait until no other thread is trying to steal a tile. */
399   while (tile_stealing_state != NOT_STEALING && stealable_tiles > 0) {
400     /* Someone else is currently trying to get a tile.
401      * Wait on the condition variable and try later. */
402     tile_steal_cond.wait(tile_lock);
403   }
404   /* If another thread stole the last stealable tile in the meantime, give up. */
405   if (stealable_tiles == 0) {
406     return false;
407   }
408
409   /* There are stealable tiles in flight, so signal that one should be released. */
410   tile_stealing_state = WAITING_FOR_TILE;
411
412   /* Wait until a device notices the signal and releases its tile. */
413   while (tile_stealing_state != GOT_TILE && stealable_tiles > 0) {
414     tile_steal_cond.wait(tile_lock);
415   }
416   /* If the last stealable tile finished on its own, give up. */
417   if (tile_stealing_state != GOT_TILE) {
418     tile_stealing_state = NOT_STEALING;
419     return false;
420   }
421
422   /* Successfully stole a tile, now move it to the new device. */
423   rtile = stolen_tile;
424   rtile.buffers->buffer.move_device(tile_device);
425   rtile.buffer = rtile.buffers->buffer.device_pointer;
426   rtile.stealing_state = RenderTile::NO_STEALING;
427   rtile.num_samples -= (rtile.sample - rtile.start_sample);
428   rtile.start_sample = rtile.sample;
429
430   tile_stealing_state = NOT_STEALING;
431
432   /* Poke any threads which might be waiting for NOT_STEALING above. */
433   tile_steal_cond.notify_one();
434
435   return true;
436 }
437
438 bool Session::get_tile_stolen()
439 {
440   /* If tile_stealing_state is WAITING_FOR_TILE, atomically set it to RELEASING_TILE
441    * and return true. */
442   TileStealingState expected = WAITING_FOR_TILE;
443   return tile_stealing_state.compare_exchange_weak(expected, RELEASING_TILE);
444 }
445
446 bool Session::acquire_tile(RenderTile &rtile, Device *tile_device, uint tile_types)
447 {
448   if (progress.get_cancel()) {
449     if (params.progressive_refine == false) {
450       /* for progressive refine current sample should be finished for all tiles */
451       return false;
452     }
453   }
454
455   thread_scoped_lock tile_lock(tile_mutex);
456
457   /* get next tile from manager */
458   Tile *tile;
459   int device_num = device->device_number(tile_device);
460
461   while (!tile_manager.next_tile(tile, device_num, tile_types)) {
462     /* Can only steal tiles on devices that support rendering
463      * This is because denoising tiles cannot be stolen (see below)
464      */
465     if ((tile_types & (RenderTile::PATH_TRACE | RenderTile::BAKE)) &&
466         steal_tile(rtile, tile_device, tile_lock)) {
467       return true;
468     }
469
470     /* Wait for denoising tiles to become available */
471     if ((tile_types & RenderTile::DENOISE) && !progress.get_cancel() && tile_manager.has_tiles()) {
472       denoising_cond.wait(tile_lock);
473       continue;
474     }
475
476     return false;
477   }
478
479   /* fill render tile */
480   rtile.x = tile_manager.state.buffer.full_x + tile->x;
481   rtile.y = tile_manager.state.buffer.full_y + tile->y;
482   rtile.w = tile->w;
483   rtile.h = tile->h;
484   rtile.start_sample = tile_manager.state.sample;
485   rtile.num_samples = tile_manager.state.num_samples;
486   rtile.resolution = tile_manager.state.resolution_divider;
487   rtile.tile_index = tile->index;
488   rtile.stealing_state = RenderTile::NO_STEALING;
489
490   if (tile->state == Tile::DENOISE) {
491     rtile.task = RenderTile::DENOISE;
492   }
493   else {
494     if (tile_device->info.type == DEVICE_CPU) {
495       stealable_tiles++;
496       rtile.stealing_state = RenderTile::CAN_BE_STOLEN;
497     }
498
499     if (read_bake_tile_cb) {
500       rtile.task = RenderTile::BAKE;
501     }
502     else {
503       rtile.task = RenderTile::PATH_TRACE;
504     }
505   }
506
507   tile_lock.unlock();
508
509   /* in case of a permanent buffer, return it, otherwise we will allocate
510    * a new temporary buffer */
511   if (buffers) {
512     tile_manager.state.buffer.get_offset_stride(rtile.offset, rtile.stride);
513
514     rtile.buffer = buffers->buffer.device_pointer;
515     rtile.buffers = buffers;
516
517     device->map_tile(tile_device, rtile);
518
519     /* Reset copy state, since buffer contents change after the tile was acquired */
520     buffers->map_neighbor_copied = false;
521
522     /* This hack ensures that the copy in 'MultiDevice::map_neighbor_tiles' accounts
523      * for the buffer resolution divider. */
524     buffers->buffer.data_width = (buffers->params.width * buffers->params.get_passes_size()) /
525                                  tile_manager.state.resolution_divider;
526     buffers->buffer.data_height = buffers->params.height / tile_manager.state.resolution_divider;
527
528     return true;
529   }
530
531   if (tile->buffers == NULL) {
532     /* fill buffer parameters */
533     BufferParams buffer_params = tile_manager.params;
534     buffer_params.full_x = rtile.x;
535     buffer_params.full_y = rtile.y;
536     buffer_params.width = rtile.w;
537     buffer_params.height = rtile.h;
538
539     /* allocate buffers */
540     tile->buffers = new RenderBuffers(tile_device);
541     tile->buffers->reset(buffer_params);
542   }
543   else if (tile->buffers->buffer.device != tile_device) {
544     /* Move buffer to current tile device again in case it was stolen before.
545      * Not needed for denoising since that already handles mapping of tiles and
546      * neighbors to its own device. */
547     if (rtile.task != RenderTile::DENOISE) {
548       tile->buffers->buffer.move_device(tile_device);
549     }
550   }
551
552   tile->buffers->map_neighbor_copied = false;
553
554   tile->buffers->params.get_offset_stride(rtile.offset, rtile.stride);
555
556   rtile.buffer = tile->buffers->buffer.device_pointer;
557   rtile.buffers = tile->buffers;
558   rtile.sample = tile_manager.state.sample;
559
560   if (read_bake_tile_cb) {
561     /* This will read any passes needed as input for baking. */
562     if (tile_manager.state.sample == tile_manager.range_start_sample) {
563       {
564         thread_scoped_lock tile_lock(tile_mutex);
565         read_bake_tile_cb(rtile);
566       }
567       rtile.buffers->buffer.copy_to_device();
568     }
569   }
570   else {
571     /* This will tag tile as IN PROGRESS in blender-side render pipeline,
572      * which is needed to highlight currently rendering tile before first
573      * sample was processed for it. */
574     update_tile_sample(rtile);
575   }
576
577   return true;
578 }
579
580 void Session::update_tile_sample(RenderTile &rtile)
581 {
582   thread_scoped_lock tile_lock(tile_mutex);
583
584   if (update_render_tile_cb) {
585     if (params.progressive_refine == false) {
586       /* todo: optimize this by making it thread safe and removing lock */
587
588       update_render_tile_cb(rtile, true);
589     }
590   }
591
592   update_status_time();
593 }
594
595 void Session::release_tile(RenderTile &rtile, const bool need_denoise)
596 {
597   thread_scoped_lock tile_lock(tile_mutex);
598
599   if (rtile.stealing_state != RenderTile::NO_STEALING) {
600     stealable_tiles--;
601     if (rtile.stealing_state == RenderTile::WAS_STOLEN) {
602       /* If the tile is being stolen, don't release it here - the new device will pick up where
603        * the old one left off. */
604
605       assert(tile_stealing_state == RELEASING_TILE);
606       assert(rtile.sample < rtile.start_sample + rtile.num_samples);
607
608       tile_stealing_state = GOT_TILE;
609       stolen_tile = rtile;
610       tile_steal_cond.notify_all();
611       return;
612     }
613     else if (stealable_tiles == 0) {
614       /* If this was the last stealable tile, wake up any threads still waiting for one. */
615       tile_steal_cond.notify_all();
616     }
617   }
618
619   progress.add_finished_tile(rtile.task == RenderTile::DENOISE);
620
621   bool delete_tile;
622
623   if (tile_manager.finish_tile(rtile.tile_index, need_denoise, delete_tile)) {
624     /* Finished tile pixels write. */
625     if (write_render_tile_cb && params.progressive_refine == false) {
626       write_render_tile_cb(rtile);
627     }
628
629     if (delete_tile) {
630       delete rtile.buffers;
631       tile_manager.state.tiles[rtile.tile_index].buffers = NULL;
632     }
633   }
634   else {
635     /* In progress tile pixels update. */
636     if (update_render_tile_cb && params.progressive_refine == false) {
637       update_render_tile_cb(rtile, false);
638     }
639   }
640
641   update_status_time();
642
643   /* Notify denoising thread that a tile was finished. */
644   denoising_cond.notify_all();
645 }
646
647 void Session::map_neighbor_tiles(RenderTileNeighbors &neighbors, Device *tile_device)
648 {
649   thread_scoped_lock tile_lock(tile_mutex);
650
651   const int4 image_region = make_int4(
652       tile_manager.state.buffer.full_x,
653       tile_manager.state.buffer.full_y,
654       tile_manager.state.buffer.full_x + tile_manager.state.buffer.width,
655       tile_manager.state.buffer.full_y + tile_manager.state.buffer.height);
656
657   RenderTile &center_tile = neighbors.tiles[RenderTileNeighbors::CENTER];
658
659   if (!tile_manager.schedule_denoising) {
660     /* Fix up tile slices with overlap. */
661     if (tile_manager.slice_overlap != 0) {
662       int y = max(center_tile.y - tile_manager.slice_overlap, image_region.y);
663       center_tile.h = min(center_tile.y + center_tile.h + tile_manager.slice_overlap,
664                           image_region.w) -
665                       y;
666       center_tile.y = y;
667     }
668
669     /* Tiles are not being denoised individually, which means the entire image is processed. */
670     neighbors.set_bounds_from_center();
671   }
672   else {
673     int center_idx = center_tile.tile_index;
674     assert(tile_manager.state.tiles[center_idx].state == Tile::DENOISE);
675
676     for (int dy = -1, i = 0; dy <= 1; dy++) {
677       for (int dx = -1; dx <= 1; dx++, i++) {
678         RenderTile &rtile = neighbors.tiles[i];
679         int nindex = tile_manager.get_neighbor_index(center_idx, i);
680         if (nindex >= 0) {
681           Tile *tile = &tile_manager.state.tiles[nindex];
682
683           rtile.x = image_region.x + tile->x;
684           rtile.y = image_region.y + tile->y;
685           rtile.w = tile->w;
686           rtile.h = tile->h;
687
688           if (buffers) {
689             tile_manager.state.buffer.get_offset_stride(rtile.offset, rtile.stride);
690
691             rtile.buffer = buffers->buffer.device_pointer;
692             rtile.buffers = buffers;
693           }
694           else {
695             assert(tile->buffers);
696             tile->buffers->params.get_offset_stride(rtile.offset, rtile.stride);
697
698             rtile.buffer = tile->buffers->buffer.device_pointer;
699             rtile.buffers = tile->buffers;
700           }
701         }
702         else {
703           int px = center_tile.x + dx * params.tile_size.x;
704           int py = center_tile.y + dy * params.tile_size.y;
705
706           rtile.x = clamp(px, image_region.x, image_region.z);
707           rtile.y = clamp(py, image_region.y, image_region.w);
708           rtile.w = rtile.h = 0;
709
710           rtile.buffer = (device_ptr)NULL;
711           rtile.buffers = NULL;
712         }
713       }
714     }
715   }
716
717   assert(center_tile.buffers);
718   device->map_neighbor_tiles(tile_device, neighbors);
719
720   /* The denoised result is written back to the original tile. */
721   neighbors.target = center_tile;
722 }
723
724 void Session::unmap_neighbor_tiles(RenderTileNeighbors &neighbors, Device *tile_device)
725 {
726   thread_scoped_lock tile_lock(tile_mutex);
727   device->unmap_neighbor_tiles(tile_device, neighbors);
728 }
729
730 void Session::run_cpu()
731 {
732   bool tiles_written = false;
733
734   last_update_time = time_dt();
735   last_display_time = last_update_time;
736
737   {
738     /* reset once to start */
739     thread_scoped_lock reset_lock(delayed_reset.mutex);
740     thread_scoped_lock buffers_lock(buffers_mutex);
741     thread_scoped_lock display_lock(display_mutex);
742
743     reset_(delayed_reset.params, delayed_reset.samples);
744     delayed_reset.do_reset = false;
745   }
746
747   while (!progress.get_cancel()) {
748     /* advance to next tile */
749     bool no_tiles = !tile_manager.next();
750     bool need_copy_to_display_buffer = false;
751
752     DeviceKernelStatus kernel_state = DEVICE_KERNEL_UNKNOWN;
753     if (no_tiles) {
754       kernel_state = device->get_active_kernel_switch_state();
755     }
756
757     if (params.background) {
758       /* if no work left and in background mode, we can stop immediately */
759       if (no_tiles) {
760         progress.set_status("Finished");
761         break;
762       }
763     }
764
765     /* Don't go in pause mode when preview kernels are used
766      * When feature kernels become available the session will be reset. */
767     else if (no_tiles && kernel_state == DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL) {
768       time_sleep(0.1);
769     }
770     else if (no_tiles && kernel_state == DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE) {
771       reset_cpu(tile_manager.params, params.samples);
772     }
773
774     else {
775       /* if in interactive mode, and we are either paused or done for now,
776        * wait for pause condition notify to wake up again */
777       thread_scoped_lock pause_lock(pause_mutex);
778
779       if (!pause && delayed_reset.do_reset) {
780         /* reset once to start */
781         thread_scoped_lock reset_lock(delayed_reset.mutex);
782         thread_scoped_lock buffers_lock(buffers_mutex);
783         thread_scoped_lock display_lock(display_mutex);
784
785         reset_(delayed_reset.params, delayed_reset.samples);
786         delayed_reset.do_reset = false;
787       }
788       else if (pause || no_tiles) {
789         update_status_time(pause, no_tiles);
790
791         while (1) {
792           scoped_timer pause_timer;
793           pause_cond.wait(pause_lock);
794           if (pause) {
795             progress.add_skip_time(pause_timer, params.background);
796           }
797
798           update_status_time(pause, no_tiles);
799           progress.set_update();
800
801           if (!pause)
802             break;
803         }
804       }
805
806       if (progress.get_cancel())
807         break;
808     }
809
810     if (!no_tiles) {
811       /* update scene */
812       scoped_timer update_timer;
813       if (update_scene()) {
814         profiler.reset(scene->shaders.size(), scene->objects.size());
815       }
816       progress.add_skip_time(update_timer, params.background);
817
818       if (!device->error_message().empty())
819         progress.set_error(device->error_message());
820
821       if (progress.get_cancel())
822         break;
823
824       /* buffers mutex is locked entirely while rendering each
825        * sample, and released/reacquired on each iteration to allow
826        * reset and draw in between */
827       thread_scoped_lock buffers_lock(buffers_mutex);
828
829       /* update status and timing */
830       update_status_time();
831
832       /* render */
833       bool delayed_denoise = false;
834       const bool need_denoise = render_need_denoise(delayed_denoise);
835       render(need_denoise);
836
837       /* update status and timing */
838       update_status_time();
839
840       if (!params.background)
841         need_copy_to_display_buffer = !delayed_denoise;
842
843       if (!device->error_message().empty())
844         progress.set_error(device->error_message());
845     }
846
847     device->task_wait();
848
849     {
850       thread_scoped_lock reset_lock(delayed_reset.mutex);
851       thread_scoped_lock buffers_lock(buffers_mutex);
852       thread_scoped_lock display_lock(display_mutex);
853
854       if (delayed_reset.do_reset) {
855         /* reset rendering if request from main thread */
856         delayed_reset.do_reset = false;
857         reset_(delayed_reset.params, delayed_reset.samples);
858       }
859       else if (need_copy_to_display_buffer) {
860         /* Only copy to display_buffer if we do not reset, we don't
861          * want to show the result of an incomplete sample */
862         copy_to_display_buffer(tile_manager.state.sample);
863       }
864
865       if (!device->error_message().empty())
866         progress.set_error(device->error_message());
867
868       tiles_written = update_progressive_refine(progress.get_cancel());
869     }
870
871     progress.set_update();
872   }
873
874   if (!tiles_written)
875     update_progressive_refine(true);
876 }
877
878 void Session::run()
879 {
880   if (params.use_profiling && (params.device.type == DEVICE_CPU)) {
881     profiler.start();
882   }
883
884   /* session thread loop */
885   progress.set_status("Waiting for render to start");
886
887   /* run */
888   if (!progress.get_cancel()) {
889     /* reset number of rendered samples */
890     progress.reset_sample();
891
892     if (device_use_gl)
893       run_gpu();
894     else
895       run_cpu();
896   }
897
898   profiler.stop();
899
900   /* progress update */
901   if (progress.get_cancel())
902     progress.set_status(progress.get_cancel_message());
903   else
904     progress.set_update();
905 }
906
907 bool Session::draw(BufferParams &buffer_params, DeviceDrawParams &draw_params)
908 {
909   if (device_use_gl)
910     return draw_gpu(buffer_params, draw_params);
911   else
912     return draw_cpu(buffer_params, draw_params);
913 }
914
915 void Session::reset_(BufferParams &buffer_params, int samples)
916 {
917   if (buffers && buffer_params.modified(tile_manager.params)) {
918     gpu_draw_ready = false;
919     buffers->reset(buffer_params);
920     if (display) {
921       display->reset(buffer_params);
922     }
923   }
924
925   tile_manager.reset(buffer_params, samples);
926   stealable_tiles = 0;
927   tile_stealing_state = NOT_STEALING;
928   progress.reset_sample();
929
930   bool show_progress = params.background || tile_manager.get_num_effective_samples() != INT_MAX;
931   progress.set_total_pixel_samples(show_progress ? tile_manager.state.total_pixel_samples : 0);
932
933   if (!params.background)
934     progress.set_start_time();
935   progress.set_render_start_time();
936 }
937
938 void Session::reset(BufferParams &buffer_params, int samples)
939 {
940   if (device_use_gl)
941     reset_gpu(buffer_params, samples);
942   else
943     reset_cpu(buffer_params, samples);
944 }
945
946 void Session::set_samples(int samples)
947 {
948   if (samples != params.samples) {
949     params.samples = samples;
950     tile_manager.set_samples(samples);
951
952     pause_cond.notify_all();
953   }
954 }
955
956 void Session::set_pause(bool pause_)
957 {
958   bool notify = false;
959
960   {
961     thread_scoped_lock pause_lock(pause_mutex);
962
963     if (pause != pause_) {
964       pause = pause_;
965       notify = true;
966     }
967   }
968
969   if (session_thread) {
970     if (notify) {
971       pause_cond.notify_all();
972     }
973   }
974   else if (pause_) {
975     update_status_time(pause_);
976   }
977 }
978
979 void Session::set_denoising(const DenoiseParams &denoising)
980 {
981   bool need_denoise = denoising.need_denoising_task();
982
983   /* Lock buffers so no denoising operation is triggered while the settings are changed here. */
984   thread_scoped_lock buffers_lock(buffers_mutex);
985   params.denoising = denoising;
986
987   if (!(params.device.denoisers & denoising.type)) {
988     if (need_denoise) {
989       progress.set_error("Denoiser type not supported by compute device");
990     }
991
992     params.denoising.use = false;
993     need_denoise = false;
994   }
995
996   // TODO(pmours): Query the required overlap value for denoising from the device?
997   tile_manager.slice_overlap = need_denoise && !params.background ? 64 : 0;
998
999   /* Schedule per tile denoising for final renders if we are either denoising or
1000    * need prefiltered passes for the native denoiser. */
1001   tile_manager.schedule_denoising = need_denoise && !buffers;
1002 }
1003
1004 void Session::set_denoising_start_sample(int sample)
1005 {
1006   if (sample != params.denoising.start_sample) {
1007     params.denoising.start_sample = sample;
1008
1009     pause_cond.notify_all();
1010   }
1011 }
1012
1013 void Session::wait()
1014 {
1015   if (session_thread) {
1016     session_thread->join();
1017     delete session_thread;
1018   }
1019
1020   session_thread = NULL;
1021 }
1022
1023 bool Session::update_scene()
1024 {
1025   thread_scoped_lock scene_lock(scene->mutex);
1026
1027   /* update camera if dimensions changed for progressive render. the camera
1028    * knows nothing about progressive or cropped rendering, it just gets the
1029    * image dimensions passed in */
1030   Camera *cam = scene->camera;
1031   int width = tile_manager.state.buffer.full_width;
1032   int height = tile_manager.state.buffer.full_height;
1033   int resolution = tile_manager.state.resolution_divider;
1034
1035   cam->set_screen_size_and_resolution(width, height, resolution);
1036
1037   /* number of samples is needed by multi jittered
1038    * sampling pattern and by baking */
1039   Integrator *integrator = scene->integrator;
1040   BakeManager *bake_manager = scene->bake_manager;
1041
1042   if (integrator->get_sampling_pattern() != SAMPLING_PATTERN_SOBOL || bake_manager->get_baking()) {
1043     integrator->set_aa_samples(tile_manager.num_samples);
1044   }
1045
1046   bool kernel_switch_needed = false;
1047   if (scene->update(progress, kernel_switch_needed)) {
1048     if (kernel_switch_needed) {
1049       reset(tile_manager.params, params.samples);
1050     }
1051     return true;
1052   }
1053   return false;
1054 }
1055
1056 void Session::update_status_time(bool show_pause, bool show_done)
1057 {
1058   int progressive_sample = tile_manager.state.sample;
1059   int num_samples = tile_manager.get_num_effective_samples();
1060
1061   int tile = progress.get_rendered_tiles();
1062   int num_tiles = tile_manager.state.num_tiles;
1063
1064   /* update status */
1065   string status, substatus;
1066
1067   if (!params.progressive) {
1068     const bool is_cpu = params.device.type == DEVICE_CPU;
1069     const bool rendering_finished = (tile == num_tiles);
1070     const bool is_last_tile = (tile + 1) == num_tiles;
1071
1072     substatus = string_printf("Rendered %d/%d Tiles", tile, num_tiles);
1073
1074     if (!rendering_finished && (device->show_samples() || (is_cpu && is_last_tile))) {
1075       /* Some devices automatically support showing the sample number:
1076        * - CUDADevice
1077        * - OpenCLDevice when using the megakernel (the split kernel renders multiple
1078        *   samples at the same time, so the current sample isn't really defined)
1079        * - CPUDevice when using one thread
1080        * For these devices, the current sample is always shown.
1081        *
1082        * The other option is when the last tile is currently being rendered by the CPU.
1083        */
1084       substatus += string_printf(", Sample %d/%d", progress.get_current_sample(), num_samples);
1085     }
1086     if (params.denoising.use && params.denoising.type != DENOISER_OPENIMAGEDENOISE) {
1087       substatus += string_printf(", Denoised %d tiles", progress.get_denoised_tiles());
1088     }
1089     else if (params.denoising.store_passes && params.denoising.type == DENOISER_NLM) {
1090       substatus += string_printf(", Prefiltered %d tiles", progress.get_denoised_tiles());
1091     }
1092   }
1093   else if (tile_manager.num_samples == Integrator::MAX_SAMPLES)
1094     substatus = string_printf("Path Tracing Sample %d", progressive_sample + 1);
1095   else
1096     substatus = string_printf("Path Tracing Sample %d/%d", progressive_sample + 1, num_samples);
1097
1098   if (show_pause) {
1099     status = "Rendering Paused";
1100   }
1101   else if (show_done) {
1102     status = "Rendering Done";
1103     progress.set_end_time(); /* Save end time so that further calls to get_time are accurate. */
1104   }
1105   else {
1106     status = substatus;
1107     substatus.clear();
1108   }
1109
1110   progress.set_status(status, substatus);
1111 }
1112
1113 bool Session::render_need_denoise(bool &delayed)
1114 {
1115   delayed = false;
1116
1117   /* Not supported yet for baking. */
1118   if (read_bake_tile_cb) {
1119     return false;
1120   }
1121
1122   /* Denoising enabled? */
1123   if (!params.denoising.need_denoising_task()) {
1124     return false;
1125   }
1126
1127   if (params.background) {
1128     /* Background render, only denoise when rendering the last sample. */
1129     return tile_manager.done();
1130   }
1131
1132   /* Viewport render. */
1133
1134   /* It can happen that denoising was already enabled, but the scene still needs an update. */
1135   if (scene->film->is_modified() || !scene->film->get_denoising_data_offset()) {
1136     return false;
1137   }
1138
1139   /* Immediately denoise when we reach the start sample or last sample. */
1140   const int num_samples_finished = tile_manager.state.sample + 1;
1141   if (num_samples_finished == params.denoising.start_sample ||
1142       num_samples_finished == params.samples) {
1143     return true;
1144   }
1145
1146   /* Do not denoise until the sample at which denoising should start is reached. */
1147   if (num_samples_finished < params.denoising.start_sample) {
1148     return false;
1149   }
1150
1151   /* Avoid excessive denoising in viewport after reaching a certain amount of samples. */
1152   delayed = (tile_manager.state.sample >= 20 &&
1153              (time_dt() - last_display_time) < params.progressive_update_timeout);
1154   return !delayed;
1155 }
1156
1157 void Session::render(bool need_denoise)
1158 {
1159   if (buffers && tile_manager.state.sample == tile_manager.range_start_sample) {
1160     /* Clear buffers. */
1161     buffers->zero();
1162   }
1163
1164   if (tile_manager.state.buffer.width == 0 || tile_manager.state.buffer.height == 0) {
1165     return; /* Avoid empty launches. */
1166   }
1167
1168   /* Add path trace task. */
1169   DeviceTask task(DeviceTask::RENDER);
1170
1171   task.acquire_tile = function_bind(&Session::acquire_tile, this, _2, _1, _3);
1172   task.release_tile = function_bind(&Session::release_tile, this, _1, need_denoise);
1173   task.map_neighbor_tiles = function_bind(&Session::map_neighbor_tiles, this, _1, _2);
1174   task.unmap_neighbor_tiles = function_bind(&Session::unmap_neighbor_tiles, this, _1, _2);
1175   task.get_cancel = function_bind(&Progress::get_cancel, &this->progress);
1176   task.update_tile_sample = function_bind(&Session::update_tile_sample, this, _1);
1177   task.update_progress_sample = function_bind(&Progress::add_samples, &this->progress, _1, _2);
1178   task.get_tile_stolen = function_bind(&Session::get_tile_stolen, this);
1179   task.need_finish_queue = params.progressive_refine;
1180   task.integrator_branched = scene->integrator->get_method() == Integrator::BRANCHED_PATH;
1181
1182   task.adaptive_sampling.use = (scene->integrator->get_sampling_pattern() ==
1183                                 SAMPLING_PATTERN_PMJ) &&
1184                                scene->dscene.data.film.pass_adaptive_aux_buffer;
1185   task.adaptive_sampling.min_samples = scene->dscene.data.integrator.adaptive_min_samples;
1186   task.adaptive_sampling.adaptive_step = scene->dscene.data.integrator.adaptive_step;
1187
1188   /* Acquire render tiles by default. */
1189   task.tile_types = RenderTile::PATH_TRACE;
1190
1191   if (need_denoise) {
1192     task.denoising = params.denoising;
1193
1194     task.pass_stride = scene->film->get_pass_stride();
1195     task.target_pass_stride = task.pass_stride;
1196     task.pass_denoising_data = scene->film->get_denoising_data_offset();
1197     task.pass_denoising_clean = scene->film->get_denoising_clean_offset();
1198
1199     task.denoising_from_render = true;
1200
1201     if (tile_manager.schedule_denoising) {
1202       /* Acquire denoising tiles during rendering. */
1203       task.tile_types |= RenderTile::DENOISE;
1204     }
1205     else {
1206       assert(buffers);
1207
1208       /* Schedule rendering and wait for it to finish. */
1209       device->task_add(task);
1210       device->task_wait();
1211
1212       /* Then run denoising on the whole image at once. */
1213       task.type = DeviceTask::DENOISE_BUFFER;
1214       task.x = tile_manager.state.buffer.full_x;
1215       task.y = tile_manager.state.buffer.full_y;
1216       task.w = tile_manager.state.buffer.width;
1217       task.h = tile_manager.state.buffer.height;
1218       task.buffer = buffers->buffer.device_pointer;
1219       task.sample = tile_manager.state.sample;
1220       task.num_samples = tile_manager.state.num_samples;
1221       tile_manager.state.buffer.get_offset_stride(task.offset, task.stride);
1222       task.buffers = buffers;
1223     }
1224   }
1225
1226   device->task_add(task);
1227 }
1228
1229 void Session::copy_to_display_buffer(int sample)
1230 {
1231   /* add film conversion task */
1232   DeviceTask task(DeviceTask::FILM_CONVERT);
1233
1234   task.x = tile_manager.state.buffer.full_x;
1235   task.y = tile_manager.state.buffer.full_y;
1236   task.w = tile_manager.state.buffer.width;
1237   task.h = tile_manager.state.buffer.height;
1238   task.rgba_byte = display->rgba_byte.device_pointer;
1239   task.rgba_half = display->rgba_half.device_pointer;
1240   task.buffer = buffers->buffer.device_pointer;
1241   task.sample = sample;
1242   tile_manager.state.buffer.get_offset_stride(task.offset, task.stride);
1243
1244   if (task.w > 0 && task.h > 0) {
1245     device->task_add(task);
1246     device->task_wait();
1247
1248     /* set display to new size */
1249     display->draw_set(task.w, task.h);
1250
1251     last_display_time = time_dt();
1252   }
1253
1254   display_outdated = false;
1255 }
1256
1257 bool Session::update_progressive_refine(bool cancel)
1258 {
1259   int sample = tile_manager.state.sample + 1;
1260   bool write = sample == tile_manager.num_samples || cancel;
1261
1262   double current_time = time_dt();
1263
1264   if (current_time - last_update_time < params.progressive_update_timeout) {
1265     /* if last sample was processed, we need to write buffers anyway  */
1266     if (!write && sample != 1)
1267       return false;
1268   }
1269
1270   if (params.progressive_refine) {
1271     foreach (Tile &tile, tile_manager.state.tiles) {
1272       if (!tile.buffers) {
1273         continue;
1274       }
1275
1276       RenderTile rtile;
1277       rtile.x = tile_manager.state.buffer.full_x + tile.x;
1278       rtile.y = tile_manager.state.buffer.full_y + tile.y;
1279       rtile.w = tile.w;
1280       rtile.h = tile.h;
1281       rtile.sample = sample;
1282       rtile.buffers = tile.buffers;
1283
1284       if (write) {
1285         if (write_render_tile_cb)
1286           write_render_tile_cb(rtile);
1287       }
1288       else {
1289         if (update_render_tile_cb)
1290           update_render_tile_cb(rtile, true);
1291       }
1292     }
1293   }
1294
1295   last_update_time = current_time;
1296
1297   return write;
1298 }
1299
1300 void Session::device_free()
1301 {
1302   scene->device_free();
1303
1304   tile_manager.device_free();
1305
1306   /* used from background render only, so no need to
1307    * re-create render/display buffers here
1308    */
1309 }
1310
1311 void Session::collect_statistics(RenderStats *render_stats)
1312 {
1313   scene->collect_statistics(render_stats);
1314   if (params.use_profiling && (params.device.type == DEVICE_CPU)) {
1315     render_stats->collect_profiling(scene, profiler);
1316   }
1317 }
1318
1319 CCL_NAMESPACE_END