6 files changed, 84 insertions, 70 deletions

diff --git a/intern/cycles/render/buffers.cpp b/intern/cycles/render/buffers.cpp
index f901885e679..66b8ef73acc 100644
--- a/intern/cycles/render/buffers.cpp
+++ b/intern/cycles/render/buffers.cpp
@@ -42,6 +42,7 @@ BufferParams::BufferParams()
 
 	denoising_data_pass = false;
 	denoising_clean_pass = false;
+	denoising_prefiltered_pass = false;
 
 	Pass::add(PASS_COMBINED, passes);
 }
@@ -73,6 +74,7 @@ int BufferParams::get_passes_size()
 	if(denoising_data_pass) {
 		size += DENOISING_PASS_SIZE_BASE;
 		if(denoising_clean_pass) size += DENOISING_PASS_SIZE_CLEAN;
+		if(denoising_prefiltered_pass) size += DENOISING_PASS_SIZE_PREFILTERED;
 	}
 
 	return align_up(size, 4);
@@ -88,6 +90,20 @@ int BufferParams::get_denoising_offset()
 	return offset;
 }
 
+int BufferParams::get_denoising_prefiltered_offset()
+{
+	assert(denoising_prefiltered_pass);
+
+	int offset = get_denoising_offset();
+
+	offset += DENOISING_PASS_SIZE_BASE;
+	if(denoising_clean_pass) {
+		offset += DENOISING_PASS_SIZE_CLEAN;
+	}
+
+	return offset;
+}
+
 /* Render Buffer Task */
 
 RenderTile::RenderTile()
@@ -153,81 +169,62 @@ bool RenderBuffers::get_denoising_pass_rect(int type, float exposure, int sample
 		return false;
 	}
 
-	float invsample = 1.0f/sample;
-	float scale = invsample;
-	bool variance = (type == DENOISING_PASS_NORMAL_VAR) ||
-	                (type == DENOISING_PASS_ALBEDO_VAR) ||
-	                (type == DENOISING_PASS_DEPTH_VAR) ||
-	                (type == DENOISING_PASS_COLOR_VAR);
+	float scale = 1.0f;
+	float alpha_scale = 1.0f/sample;
+	if(type == DENOISING_PASS_PREFILTERED_COLOR ||
+	   type == DENOISING_PASS_CLEAN ||
+	   type == DENOISING_PASS_PREFILTERED_INTENSITY) {
+		scale *= exposure;
+	}
+	else if(type == DENOISING_PASS_PREFILTERED_VARIANCE) {
+		scale *= exposure*exposure * (sample - 1);
+	}
 
-	float scale_exposure = scale;
-	if(type == DENOISING_PASS_COLOR || type == DENOISING_PASS_CLEAN) {
-		scale_exposure *= exposure;
+	int offset;
+	if(type == DENOISING_PASS_CLEAN) {
+		/* The clean pass isn't changed by prefiltering, so we use the original one there. */
+		offset = type + params.get_denoising_offset();
 	}
-	else if(type == DENOISING_PASS_COLOR_VAR) {
-		scale_exposure *= exposure*exposure;
+	else if (type == DENOISING_PASS_PREFILTERED_COLOR && !params.denoising_prefiltered_pass) {
+		/* If we're not saving the prefiltering result, return the original noisy pass. */
+		offset = params.get_denoising_offset() + DENOISING_PASS_COLOR;
+		scale /= sample;
+	}
+	else {
+		offset = type + params.get_denoising_prefiltered_offset();
 	}
 
-	int offset = type + params.get_denoising_offset();
 	int pass_stride = params.get_passes_size();
 	int size = params.width*params.height;
 
-	if(variance) {
-		/* Approximate variance as E[x^2] - 1/N * (E[x])^2, since online variance
-		 * update does not work efficiently with atomics in the kernel. */
-		int mean_offset = offset - components;
-		float *mean = buffer.data() + mean_offset;
-		float *var = buffer.data() + offset;
-		assert(mean_offset >= 0);
-
-		if(components == 1) {
-			for(int i = 0; i < size; i++, mean += pass_stride, var += pass_stride, pixels++) {
-				pixels[0] = max(0.0f, var[0] - mean[0]*mean[0]*invsample)*scale_exposure;
-			}
+	float *in = buffer.data() + offset;
+
+	if(components == 1) {
+		for(int i = 0; i < size; i++, in += pass_stride, pixels++) {
+			pixels[0] = in[0]*scale;
 		}
-		else if(components == 3) {
-			for(int i = 0; i < size; i++, mean += pass_stride, var += pass_stride, pixels += 3) {
-				pixels[0] = max(0.0f, var[0] - mean[0]*mean[0]*invsample)*scale_exposure;
-				pixels[1] = max(0.0f, var[1] - mean[1]*mean[1]*invsample)*scale_exposure;
-				pixels[2] = max(0.0f, var[2] - mean[2]*mean[2]*invsample)*scale_exposure;
-			}
+	}
+	else if(components == 3) {
+		for(int i = 0; i < size; i++, in += pass_stride, pixels += 3) {
+			pixels[0] = in[0]*scale;
+			pixels[1] = in[1]*scale;
+			pixels[2] = in[2]*scale;
 		}
-		else {
-			return false;
+	}
+	else if(components == 4) {
+		/* Since the alpha channel is not involved in denoising, output the Combined alpha channel. */
+		assert(params.passes[0].type == PASS_COMBINED);
+		float *in_combined = buffer.data();
+
+		for(int i = 0; i < size; i++, in += pass_stride, in_combined += pass_stride, pixels += 4) {
+			pixels[0] = in[0]*scale;
+			pixels[1] = in[1]*scale;
+			pixels[2] = in[2]*scale;
+			pixels[3] = saturate(in_combined[3]*alpha_scale);
 		}
 	}
 	else {
-		float *in = buffer.data() + offset;
-
-		if(components == 1) {
-			for(int i = 0; i < size; i++, in += pass_stride, pixels++) {
-				pixels[0] = in[0]*scale_exposure;
-			}
-		}
-		else if(components == 3) {
-			for(int i = 0; i < size; i++, in += pass_stride, pixels += 3) {
-				pixels[0] = in[0]*scale_exposure;
-				pixels[1] = in[1]*scale_exposure;
-				pixels[2] = in[2]*scale_exposure;
-			}
-		}
-		else if(components == 4) {
-			assert(type == DENOISING_PASS_COLOR);
-
-			/* Since the alpha channel is not involved in denoising, output the Combined alpha channel. */
-			assert(params.passes[0].type == PASS_COMBINED);
-			float *in_combined = buffer.data();
-
-			for(int i = 0; i < size; i++, in += pass_stride, in_combined += pass_stride, pixels += 4) {
-				pixels[0] = in[0]*scale_exposure;
-				pixels[1] = in[1]*scale_exposure;
-				pixels[2] = in[2]*scale_exposure;
-				pixels[3] = saturate(in_combined[3]*scale);
-			}
-		}
-		else {
-			return false;
-		}
+		return false;
 	}
 
 	return true;
diff --git a/intern/cycles/render/buffers.h b/intern/cycles/render/buffers.h
index 46c3b89bd84..0a010718d6d 100644
--- a/intern/cycles/render/buffers.h
+++ b/intern/cycles/render/buffers.h
@@ -54,6 +54,10 @@ public:
 	bool denoising_data_pass;
 	/* If only some light path types should be denoised, an additional pass is needed. */
 	bool denoising_clean_pass;
+	/* When we're prefiltering the passes during rendering, we need to keep both the
+	 * original and the prefiltered data around because neighboring tiles might still
+	 * need the original data. */
+	bool denoising_prefiltered_pass;
 
 	/* functions */
 	BufferParams();
@@ -63,6 +67,7 @@ public:
 	void add_pass(PassType type);
 	int get_passes_size();
 	int get_denoising_offset();
+	int get_denoising_prefiltered_offset();
 };
 
 /* Render Buffers */
diff --git a/intern/cycles/render/film.cpp b/intern/cycles/render/film.cpp
index d0f15496e50..b305fa59123 100644
--- a/intern/cycles/render/film.cpp
+++ b/intern/cycles/render/film.cpp
@@ -286,6 +286,7 @@ NODE_DEFINE(Film)
 
 	SOCKET_BOOLEAN(denoising_data_pass,  "Generate Denoising Data Pass",  false);
 	SOCKET_BOOLEAN(denoising_clean_pass, "Generate Denoising Clean Pass", false);
+	SOCKET_BOOLEAN(denoising_prefiltered_pass, "Generate Denoising Prefiltered Pass", false);
 	SOCKET_INT(denoising_flags, "Denoising Flags", 0);
 
 	return type;
@@ -469,6 +470,9 @@ void Film::device_update(Device *device, DeviceScene *dscene, Scene *scene)
 			kfilm->pass_stride += DENOISING_PASS_SIZE_CLEAN;
 			kfilm->use_light_pass = 1;
 		}
+		if(denoising_prefiltered_pass) {
+			kfilm->pass_stride += DENOISING_PASS_SIZE_PREFILTERED;
+		}
 	}
 
 	kfilm->pass_stride = align_up(kfilm->pass_stride, 4);
diff --git a/intern/cycles/render/film.h b/intern/cycles/render/film.h
index c597db4e4c5..8330a4cf413 100644
--- a/intern/cycles/render/film.h
+++ b/intern/cycles/render/film.h
@@ -60,6 +60,7 @@ public:
 	vector<Pass> passes;
 	bool denoising_data_pass;
 	bool denoising_clean_pass;
+	bool denoising_prefiltered_pass;
 	int denoising_flags;
 	float pass_alpha_threshold;
 
diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index c818f2b496c..3cee3b8bece 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -689,7 +689,7 @@ DeviceRequestedFeatures Session::get_requested_device_features()
 	BakeManager *bake_manager = scene->bake_manager;
 	requested_features.use_baking = bake_manager->get_baking();
 	requested_features.use_integrator_branched = (scene->integrator->method == Integrator::BRANCHED_PATH);
-	if(params.denoising_passes) {
+	if(params.run_denoising) {
 		requested_features.use_denoising = true;
 		requested_features.use_shadow_tricks = true;
 	}
@@ -927,7 +927,7 @@ void Session::update_status_time(bool show_pause, bool show_done)
 			 */
 			substatus += string_printf(", Sample %d/%d", progress.get_current_sample(), num_samples);
 		}
-		if(params.use_denoising) {
+		if(params.run_denoising) {
 			substatus += string_printf(", Denoised %d tiles", progress.get_denoised_tiles());
 		}
 	}
@@ -975,7 +975,7 @@ void Session::render()
 	task.requested_tile_size = params.tile_size;
 	task.passes_size = tile_manager.params.get_passes_size();
 
-	if(params.use_denoising) {
+	if(params.run_denoising) {
 		task.denoising_radius = params.denoising_radius;
 		task.denoising_strength = params.denoising_strength;
 		task.denoising_feature_strength = params.denoising_feature_strength;
@@ -983,8 +983,13 @@ void Session::render()
 
 		assert(!scene->film->need_update);
 		task.pass_stride = scene->film->pass_stride;
+		task.target_pass_stride = task.pass_stride;
 		task.pass_denoising_data = scene->film->denoising_data_offset;
 		task.pass_denoising_clean = scene->film->denoising_clean_offset;
+
+		task.denoising_from_render = true;
+		task.denoising_do_filter = params.full_denoising;
+		task.denoising_write_passes = params.write_denoising_passes;
 	}
 
 	device->task_add(task);
diff --git a/intern/cycles/render/session.h b/intern/cycles/render/session.h
index c7f590915e7..cb1d8fed68f 100644
--- a/intern/cycles/render/session.h
+++ b/intern/cycles/render/session.h
@@ -60,8 +60,9 @@ public:
 
 	bool display_buffer_linear;
 
-	bool use_denoising;
-	bool denoising_passes;
+	bool run_denoising;
+	bool write_denoising_passes;
+	bool full_denoising;
 	int denoising_radius;
 	float denoising_strength;
 	float denoising_feature_strength;
@@ -94,8 +95,9 @@ public:
 
 		use_profiling = false;
 
-		use_denoising = false;
-		denoising_passes = false;
+		run_denoising = false;
+		write_denoising_passes = false;
+		full_denoising = false;
 		denoising_radius = 8;
 		denoising_strength = 0.0f;
 		denoising_feature_strength = 0.0f;