Removed parameter from executePixel and initializeTileData.

256 files changed, 762 insertions, 763 deletions

diff --git a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
index 0496974c64f..d14b8c48c89 100644
--- a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
+++ b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
@@ -33,7 +33,7 @@ void SingleThreadedNodeOperation::initExecution()
 	initMutex();
 }
 
-void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, void *data)
 {
 	this->m_cachedInstance->readNoCheck(color, x, y);
 }
@@ -46,14 +46,14 @@ void SingleThreadedNodeOperation::deinitExecution()
 		this->m_cachedInstance = NULL;
 	}
 }
-void *SingleThreadedNodeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *SingleThreadedNodeOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_cachedInstance) return this->m_cachedInstance;
 	
 	lockMutex();
 	if (this->m_cachedInstance == NULL) {
 		//
-		this->m_cachedInstance = createMemoryBuffer(rect, memoryBuffers);
+		this->m_cachedInstance = createMemoryBuffer(rect);
 	}
 	unlockMutex();
 	return this->m_cachedInstance;
diff --git a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
index c6db5381f48..68951eab507 100644
--- a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
+++ b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
@@ -51,9 +51,9 @@ public:
 	 */
 	void deinitExecution();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
-	virtual MemoryBuffer *createMemoryBuffer(rcti *rect, MemoryBuffer **memoryBuffers) = 0;
+	virtual MemoryBuffer *createMemoryBuffer(rcti *rect) = 0;
 	
 	int isSingleThreaded() { return true; }
 };
diff --git a/source/blender/compositor/intern/COM_SocketReader.h b/source/blender/compositor/intern/COM_SocketReader.h
index 0f35fcfb0df..736dd2fc8b6 100644
--- a/source/blender/compositor/intern/COM_SocketReader.h
+++ b/source/blender/compositor/intern/COM_SocketReader.h
@@ -63,7 +63,7 @@ protected:
 	 * @param y the y-coordinate of the pixel to calculate in image space
 	 * @param inputBuffers chunks that can be read by their ReadBufferOperation.
 	 */
-	virtual void executePixel(float *result, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {}
+	virtual void executePixel(float *result, float x, float y, PixelSampler sampler) {}
 
 	/**
 	 * @brief calculate a single pixel
@@ -74,8 +74,8 @@ protected:
 	 * @param inputBuffers chunks that can be read by their ReadBufferOperation.
 	 * @param chunkData chunk specific data a during execution time.
 	 */
-	virtual void executePixel(float *result, int x, int y, MemoryBuffer *inputBuffers[], void *chunkData) {
-		executePixel(result, x, y, COM_PS_NEAREST, inputBuffers);
+	virtual void executePixel(float *result, int x, int y, void *chunkData) {
+		executePixel(result, x, y, COM_PS_NEAREST);
 	}
 
 	/**
@@ -88,21 +88,21 @@ protected:
 	 * @param dy
 	 * @param inputBuffers chunks that can be read by their ReadBufferOperation.
 	 */
-	virtual void executePixel(float *result, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {}
+	virtual void executePixel(float *result, float x, float y, float dx, float dy) {}
 
 public:
-	inline void read(float *result, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {
-		executePixel(result, x, y, sampler, inputBuffers);
+	inline void read(float *result, float x, float y, PixelSampler sampler) {
+		executePixel(result, x, y, sampler);
 	}
-	inline void read(float *result, int x, int y, MemoryBuffer *inputBuffers[], void *chunkData) {
-		executePixel(result, x, y, inputBuffers, chunkData);
+	inline void read(float *result, int x, int y, void *chunkData) {
+		executePixel(result, x, y, chunkData);
 	}
-	inline void read(float *result, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {
-		executePixel(result, x, y, dx, dy, inputBuffers);
+	inline void read(float *result, float x, float y, float dx, float dy) {
+		executePixel(result, x, y, dx, dy);
 	}
 
-	virtual void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { return 0; }
-	virtual void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data) {
+	virtual void *initializeTileData(rcti *rect) { return 0; }
+	virtual void deinitializeTileData(rcti *rect, void *data) {
 	}
 	
 	virtual MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) { return 0; }
diff --git a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
index e688332a039..406a98f81e9 100644
--- a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
+++ b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
@@ -27,15 +27,15 @@ AlphaOverKeyOperation::AlphaOverKeyOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputOverColor[4];
 	float value[4];
 	
-	this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(value, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
 	
 	if (inputOverColor[3] <= 0.0f) {
 		copy_v4_v4(outputValue, inputColor1);
diff --git a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h
index 113ec245ee6..5f430efb98e 100644
--- a/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h
+++ b/source/blender/compositor/operations/COM_AlphaOverKeyOperation.h
@@ -39,6 +39,6 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
index e56fb9151f2..b94486b5b4f 100644
--- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
+++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
@@ -27,15 +27,15 @@ AlphaOverMixedOperation::AlphaOverMixedOperation() : MixBaseOperation()
 	this->m_x = 0.0f;
 }
 
-void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputOverColor[4];
 	float value[4];
 	
-	this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(value, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
 	
 	if (inputOverColor[3] <= 0.0f) {
 		copy_v4_v4(outputValue, inputColor1);
diff --git a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h
index 3c0b955e360..308f139884d 100644
--- a/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h
+++ b/source/blender/compositor/operations/COM_AlphaOverMixedOperation.h
@@ -41,7 +41,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void setX(float x) { this->m_x = x; }
 };
diff --git a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
index b2c40a058ba..dad43f3b179 100644
--- a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
+++ b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
@@ -27,15 +27,15 @@ AlphaOverPremultiplyOperation::AlphaOverPremultiplyOperation() : MixBaseOperatio
 	/* pass */
 }
 
-void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputOverColor[4];
 	float value[4];
 	
-	this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(value, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
 	
 	/* Zero alpha values should still permit an add of RGB data */
 	if (inputOverColor[3] < 0.0f) {
diff --git a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h
index 7b7b9238794..37ddc6dcda5 100644
--- a/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h
+++ b/source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.cpp b/source/blender/compositor/operations/COM_AntiAliasOperation.cpp
index 46fa07893e8..27ba2ef51f6 100644
--- a/source/blender/compositor/operations/COM_AntiAliasOperation.cpp
+++ b/source/blender/compositor/operations/COM_AntiAliasOperation.cpp
@@ -42,7 +42,7 @@ void AntiAliasOperation::initExecution()
 	NodeOperation::initMutex();
 }
 
-void AntiAliasOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void AntiAliasOperation::executePixel(float *color, int x, int y, void *data)
 {
 	if (y < 0 || (unsigned int)y >= this->m_height || x < 0 || (unsigned int)x >= this->m_width) {
 		color[0] = 0.0f;
@@ -82,12 +82,12 @@ bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe
 	return false;
 }
 
-void *AntiAliasOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *AntiAliasOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_buffer) { return this->m_buffer; }
 	lockMutex();
 	if (this->m_buffer == NULL) {
-		MemoryBuffer *tile = (MemoryBuffer *)this->m_valueReader->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *tile = (MemoryBuffer *)this->m_valueReader->initializeTileData(rect);
 		int size = tile->getHeight() * tile->getWidth();
 		float *input = tile->getBuffer();
 		char *valuebuffer = new char[size];
diff --git a/source/blender/compositor/operations/COM_AntiAliasOperation.h b/source/blender/compositor/operations/COM_AntiAliasOperation.h
index 3d9bcf6d90a..7489d2e393a 100644
--- a/source/blender/compositor/operations/COM_AntiAliasOperation.h
+++ b/source/blender/compositor/operations/COM_AntiAliasOperation.h
@@ -43,14 +43,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	
 	/**
 	 * Deinitialize the execution
diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp b/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp
index 4f7f5eea8a0..1db3ecb2db8 100644
--- a/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.cpp
@@ -46,7 +46,7 @@ void BilateralBlurOperation::initExecution()
 	QualityStepHelper::initExecution(COM_QH_INCREASE);
 }
 
-void BilateralBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void BilateralBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	// read the determinator color at x, y, this will be used as the reference color for the determinator
 	float determinatorReferenceColor[4];
@@ -61,20 +61,20 @@ void BilateralBlurOperation::executePixel(float *color, int x, int y, MemoryBuff
 	int miny = floor(y - space);
 	int maxy = ceil(y + space);
 	float deltaColor;
-	this->m_inputDeterminatorProgram->read(determinatorReferenceColor, x, y, inputBuffers, data);
+	this->m_inputDeterminatorProgram->read(determinatorReferenceColor, x, y, data);
 
 	zero_v4(blurColor);
 	blurDivider = 0.0f;
 	for (int yi = miny; yi < maxy; yi += QualityStepHelper::getStep()) {
 		for (int xi = minx; xi < maxx; xi += QualityStepHelper::getStep()) {
 			// read determinator
-			this->m_inputDeterminatorProgram->read(determinator, xi, yi, inputBuffers, data);
+			this->m_inputDeterminatorProgram->read(determinator, xi, yi, data);
 			deltaColor = (fabsf(determinatorReferenceColor[0] - determinator[0]) +
 			              fabsf(determinatorReferenceColor[1] - determinator[1]) +
 			              fabsf(determinatorReferenceColor[2] - determinator[2])); // do not take the alpha channel into account
 			if (deltaColor < sigmacolor) {
 				// add this to the blur
-				this->m_inputColorProgram->read(tempColor, xi, yi, inputBuffers, data);
+				this->m_inputColorProgram->read(tempColor, xi, yi, data);
 				add_v4_v4(blurColor, tempColor);
 				blurDivider += 1.0f;
 			}
diff --git a/source/blender/compositor/operations/COM_BilateralBlurOperation.h b/source/blender/compositor/operations/COM_BilateralBlurOperation.h
index be6ce7a221e..c1b5f764f01 100644
--- a/source/blender/compositor/operations/COM_BilateralBlurOperation.h
+++ b/source/blender/compositor/operations/COM_BilateralBlurOperation.h
@@ -38,7 +38,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.cpp b/source/blender/compositor/operations/COM_BlurBaseOperation.cpp
index 696c0748d69..98aeba41ecb 100644
--- a/source/blender/compositor/operations/COM_BlurBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_BlurBaseOperation.cpp
@@ -140,11 +140,11 @@ void BlurBaseOperation::deinitExecution()
 	this->m_data = NULL;
 }
 
-void BlurBaseOperation::updateSize(MemoryBuffer **memoryBuffers)
+void BlurBaseOperation::updateSize()
 {
 	if (!this->m_sizeavailable) {
 		float result[4];
-		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers);
+		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST);
 		this->m_size = result[0];
 		this->m_sizeavailable = true;
 	}
diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.h b/source/blender/compositor/operations/COM_BlurBaseOperation.h
index 6d60abf09bf..d8729ad4394 100644
--- a/source/blender/compositor/operations/COM_BlurBaseOperation.h
+++ b/source/blender/compositor/operations/COM_BlurBaseOperation.h
@@ -34,7 +34,7 @@ protected:
 	float *make_gausstab(int rad);
 	float *make_dist_fac_inverse(int rad, int falloff);
 
-	void updateSize(MemoryBuffer **memoryBuffers);
+	void updateSize();
 
 	/**
 	 * Cached reference to the inputProgram
diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.cpp b/source/blender/compositor/operations/COM_BokehBlurOperation.cpp
index a0cc8df826a..ff9bfb73396 100644
--- a/source/blender/compositor/operations/COM_BokehBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_BokehBlurOperation.cpp
@@ -45,13 +45,13 @@ BokehBlurOperation::BokehBlurOperation() : NodeOperation()
 	this->m_inputBoundingBoxReader = NULL;
 }
 
-void *BokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *BokehBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_sizeavailable) {
-		updateSize(memoryBuffers);
+		updateSize();
 	}
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	unlockMutex();
 	return buffer;
 }
@@ -79,13 +79,13 @@ void BokehBlurOperation::initExecution()
 	QualityStepHelper::initExecution(COM_QH_INCREASE);
 }
 
-void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void BokehBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float color_accum[4];
 	float tempBoundingBox[4];
 	float bokeh[4];
 
-	this->m_inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST);
 	if (tempBoundingBox[0] > 0.0f) {
 		float multiplier_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 		MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
@@ -95,7 +95,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
 		int bufferstarty = inputBuffer->getRect()->ymin;
 		int pixelSize = this->m_size * this->getWidth() / 100.0f;
 		if (pixelSize==0){
-			this->m_inputProgram->read(color, x, y, COM_PS_NEAREST, inputBuffers);
+			this->m_inputProgram->read(color, x, y, COM_PS_NEAREST);
 			return;
 		}
 		int miny = y - pixelSize;
@@ -118,7 +118,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
 			for (int nx = minx; nx < maxx; nx += step) {
 				float u = this->m_bokehMidX - (nx - x) * m;
 				float v = this->m_bokehMidY - (ny - y) * m;
-				this->m_inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers);
+				this->m_inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST);
 				madd_v4_v4v4(color_accum, bokeh, &buffer[bufferindex]);
 				add_v4_v4(multiplier_accum, bokeh);
 				bufferindex += offsetadd;
@@ -130,7 +130,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
 		color[3] = color_accum[3] * (1.0f / multiplier_accum[3]);
 	}
 	else {
-		this->m_inputProgram->read(color, x, y, COM_PS_NEAREST, inputBuffers);
+		this->m_inputProgram->read(color, x, y, COM_PS_NEAREST);
 	}
 }
 
@@ -196,7 +196,7 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice* device,
 {
 	cl_kernel kernel = device->COM_clCreateKernel("bokehBlurKernel", NULL);
 	if (!this->m_sizeavailable) {
-		updateSize(inputMemoryBuffers);
+		updateSize();
 	}
 	cl_int radius = this->getWidth() * this->m_size / 100.0f;
 	cl_int step = this->getStep();
@@ -213,11 +213,11 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice* device,
 	device->COM_clEnqueueRange(kernel, outputMemoryBuffer, 9, this);
 }
 
-void BokehBlurOperation::updateSize(MemoryBuffer **memoryBuffers)
+void BokehBlurOperation::updateSize()
 {
 	if (!this->m_sizeavailable) {
 		float result[4];
-		this->getInputSocketReader(3)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers);
+		this->getInputSocketReader(3)->read(result, 0, 0, COM_PS_NEAREST);
 		this->m_size = result[0];
 		CLAMP(this->m_size, 0.0f, 10.0f);
 		this->m_sizeavailable = true;
diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.h b/source/blender/compositor/operations/COM_BokehBlurOperation.h
index 407118b17a5..eef5429c409 100644
--- a/source/blender/compositor/operations/COM_BokehBlurOperation.h
+++ b/source/blender/compositor/operations/COM_BokehBlurOperation.h
@@ -30,7 +30,7 @@ private:
 	SocketReader *m_inputProgram;
 	SocketReader *m_inputBokehProgram;
 	SocketReader *m_inputBoundingBoxReader;
-	void updateSize(MemoryBuffer **memoryBuffers);
+	void updateSize();
 	float m_size;
 	bool m_sizeavailable;
 	float m_bokehMidX;
@@ -39,11 +39,11 @@ private:
 public:
 	BokehBlurOperation();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.cpp b/source/blender/compositor/operations/COM_BokehImageOperation.cpp
index 90e272438d6..d7de201e9df 100644
--- a/source/blender/compositor/operations/COM_BokehImageOperation.cpp
+++ b/source/blender/compositor/operations/COM_BokehImageOperation.cpp
@@ -87,7 +87,7 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
 	}
 	return insideBokeh;
 }
-void BokehImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void BokehImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float shift = this->m_data->lensshift;
 	float shift2 = shift / 2.0f;
diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.h b/source/blender/compositor/operations/COM_BokehImageOperation.h
index 085aaa471f0..a797d0fca53 100644
--- a/source/blender/compositor/operations/COM_BokehImageOperation.h
+++ b/source/blender/compositor/operations/COM_BokehImageOperation.h
@@ -47,7 +47,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.cpp b/source/blender/compositor/operations/COM_BoxMaskOperation.cpp
index 96738a2920a..a0fb37f4310 100644
--- a/source/blender/compositor/operations/COM_BoxMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_BoxMaskOperation.cpp
@@ -44,7 +44,7 @@ void BoxMaskOperation::initExecution()
 	this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight();
 }
 
-void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputMask[4];
 	float inputValue[4];
@@ -57,8 +57,8 @@ void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler
 	rx = this->m_data->x + (this->m_cosine * dx + this->m_sine * dy);
 	ry = this->m_data->y + (-this->m_sine * dx + this->m_cosine * dy);
 	
-	this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers);
-	this->m_inputValue->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputMask->read(inputMask, x, y, sampler);
+	this->m_inputValue->read(inputValue, x, y, sampler);
 	
 	float halfHeight = this->m_data->height / 2.0f;
 	float halfWidth = this->m_data->width / 2.0f;
diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.h b/source/blender/compositor/operations/COM_BoxMaskOperation.h
index cec680ef6c3..5a6745d9a9b 100644
--- a/source/blender/compositor/operations/COM_BoxMaskOperation.h
+++ b/source/blender/compositor/operations/COM_BoxMaskOperation.h
@@ -45,7 +45,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.cpp b/source/blender/compositor/operations/COM_BrightnessOperation.cpp
index 8c9fb6394a7..9a6a930c7c9 100644
--- a/source/blender/compositor/operations/COM_BrightnessOperation.cpp
+++ b/source/blender/compositor/operations/COM_BrightnessOperation.cpp
@@ -37,15 +37,15 @@ void BrightnessOperation::initExecution()
 	this->m_inputContrastProgram = this->getInputSocketReader(2);
 }
 
-void BrightnessOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void BrightnessOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	float a, b;
 	float inputBrightness[4];
 	float inputContrast[4];
-	this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputBrightnessProgram->read(inputBrightness, x, y, sampler, inputBuffers);
-	this->m_inputContrastProgram->read(inputContrast, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(inputValue, x, y, sampler);
+	this->m_inputBrightnessProgram->read(inputBrightness, x, y, sampler);
+	this->m_inputContrastProgram->read(inputContrast, x, y, sampler);
 	float brightness = inputBrightness[0];
 	float contrast = inputContrast[0];
 	brightness /= 100.0f;
diff --git a/source/blender/compositor/operations/COM_BrightnessOperation.h b/source/blender/compositor/operations/COM_BrightnessOperation.h
index 61f667aa1be..2a6200ad9df 100644
--- a/source/blender/compositor/operations/COM_BrightnessOperation.h
+++ b/source/blender/compositor/operations/COM_BrightnessOperation.h
@@ -40,7 +40,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp b/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp
index a1c679b3e15..b0cfdb44736 100644
--- a/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp
+++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.cpp
@@ -42,7 +42,7 @@ void CalculateMeanOperation::initExecution()
 	NodeOperation::initMutex();
 }
 
-void CalculateMeanOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void CalculateMeanOperation::executePixel(float *color, int x, int y, void *data)
 {
 	color[0] = this->m_result;
 }
@@ -70,11 +70,11 @@ bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti *input, ReadB
 	return false;
 }
 
-void *CalculateMeanOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *CalculateMeanOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_iscalculated) {
-		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect);
 		calculateMean(tile);
 		this->m_iscalculated = true;
 	}
diff --git a/source/blender/compositor/operations/COM_CalculateMeanOperation.h b/source/blender/compositor/operations/COM_CalculateMeanOperation.h
index 2bd723c40a3..09727533306 100644
--- a/source/blender/compositor/operations/COM_CalculateMeanOperation.h
+++ b/source/blender/compositor/operations/COM_CalculateMeanOperation.h
@@ -46,14 +46,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	
 	/**
 	 * Deinitialize the execution
diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
index 2d860df449c..de602ba1dd6 100644
--- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
+++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
@@ -31,16 +31,16 @@ CalculateStandardDeviationOperation::CalculateStandardDeviationOperation() : Cal
 	/* pass */
 }
 
-void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, void *data)
 {
 	color[0] = this->m_standardDeviation;
 }
 
-void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_iscalculated) {
-		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect);
 		CalculateMeanOperation::calculateMean(tile);
 		this->m_standardDeviation = 0.0f;
 		float *buffer = tile->getBuffer();
diff --git a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
index 506c5d6fe3a..311cedd7d32 100644
--- a/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
+++ b/source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
@@ -39,9 +39,9 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp b/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
index 0812dd45bf6..7a6a22e5c05 100644
--- a/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
+++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
@@ -39,11 +39,11 @@ void ChangeHSVOperation::deinitExecution()
 	this->m_inputOperation = NULL;
 }
 
-void ChangeHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ChangeHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	
-	this->m_inputOperation->read(inputColor1, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor1, x, y, sampler);
 	
 	outputValue[0] = inputColor1[0] + (this->m_hue - 0.5f);
 	if      (outputValue[0] > 1.0f) outputValue[0] -= 1.0f;
diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.h b/source/blender/compositor/operations/COM_ChangeHSVOperation.h
index ee35fbe01d4..e5660e44f73 100644
--- a/source/blender/compositor/operations/COM_ChangeHSVOperation.h
+++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.h
@@ -49,7 +49,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void setHue(float hue) { this->m_hue = hue; }
 	void setSaturation(float saturation) { this->m_saturation = saturation; }
diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp b/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp
index b2de934e6d8..85f606fafdf 100644
--- a/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.cpp
@@ -83,7 +83,7 @@ void ChannelMatteOperation::deinitExecution()
 	this->m_inputImageProgram = NULL;
 }
 
-void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inColor[4];
 	float alpha;
@@ -92,7 +92,7 @@ void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, P
 	const float limit_min = this->m_limit_min;
 	const float limit_range = this->m_limit_range;
 
-	this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers);
+	this->m_inputImageProgram->read(inColor, x, y, sampler);
 
 	/* matte operation */
 	alpha = inColor[this->m_ids[0]] - max(inColor[this->m_ids[1]], inColor[this->m_ids[2]]);
diff --git a/source/blender/compositor/operations/COM_ChannelMatteOperation.h b/source/blender/compositor/operations/COM_ChannelMatteOperation.h
index ee17036a78d..a02d0618a4c 100644
--- a/source/blender/compositor/operations/COM_ChannelMatteOperation.h
+++ b/source/blender/compositor/operations/COM_ChannelMatteOperation.h
@@ -59,7 +59,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp b/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp
index e88feb6db9c..85a19d7c60f 100644
--- a/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.cpp
@@ -44,7 +44,7 @@ void ChromaMatteOperation::deinitExecution()
 	this->m_inputKeyProgram = NULL;
 }
 
-void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inKey[4];
 	float inImage[4];
@@ -57,8 +57,8 @@ void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, Pi
 	float theta, beta;
 	float kfg;
 
-	this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers);
-	this->m_inputImageProgram->read(inImage, x, y, sampler, inputBuffers);
+	this->m_inputKeyProgram->read(inKey, x, y, sampler);
+	this->m_inputImageProgram->read(inImage, x, y, sampler);
 
 	/* store matte(alpha) value in [0] to go with
 	 * COM_SetAlphaOperation and the Value output
diff --git a/source/blender/compositor/operations/COM_ChromaMatteOperation.h b/source/blender/compositor/operations/COM_ChromaMatteOperation.h
index eaca05e66ca..37b58fa45ed 100644
--- a/source/blender/compositor/operations/COM_ChromaMatteOperation.h
+++ b/source/blender/compositor/operations/COM_ChromaMatteOperation.h
@@ -42,7 +42,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
index 66ce86234b7..33e6db22ef4 100644
--- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
@@ -49,13 +49,13 @@ void ColorBalanceASCCDLOperation::initExecution()
 	this->m_inputColorOperation = this->getInputSocketReader(1);
 }
 
-void ColorBalanceASCCDLOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorBalanceASCCDLOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
 	float value[4];
 	
-	this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-	this->m_inputColorOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(value, x, y, sampler);
+	this->m_inputColorOperation->read(inputColor, x, y, sampler);
 	
 	float fac = value[0];
 	fac = min(1.0f, fac);
diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h
index a9c0dff9ad4..d6361ea16ba 100644
--- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h
+++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h
@@ -49,7 +49,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp
index 13863a9ec5a..b0691925361 100644
--- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp
@@ -54,13 +54,13 @@ void ColorBalanceLGGOperation::initExecution()
 	this->m_inputColorOperation = this->getInputSocketReader(1);
 }
 
-void ColorBalanceLGGOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorBalanceLGGOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
 	float value[4];
 	
-	this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-	this->m_inputColorOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(value, x, y, sampler);
+	this->m_inputColorOperation->read(inputColor, x, y, sampler);
 	
 	float fac = value[0];
 	fac = min(1.0f, fac);
diff --git a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h
index ffc78fae6f1..c3d44c53e53 100644
--- a/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h
+++ b/source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h
@@ -50,7 +50,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
index 8008866752f..ebc818b0f7e 100644
--- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
@@ -40,12 +40,12 @@ void ColorCorrectionOperation::initExecution()
 	this->m_inputMask = this->getInputSocketReader(1);
 }
 
-void ColorCorrectionOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorCorrectionOperation::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
 	float inputImageColor[4];
 	float inputMask[4];
-	this->m_inputImage->read(inputImageColor, x, y, sampler, inputBuffers);
-	this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers);
+	this->m_inputImage->read(inputImageColor, x, y, sampler);
+	this->m_inputMask->read(inputMask, x, y, sampler);
 	
 	float level = (inputImageColor[0] + inputImageColor[1] + inputImageColor[2]) / 3.0f;
 	float contrast = this->m_data->master.contrast;
diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h
index 8db3870709e..685413741fa 100644
--- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.h
+++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.cpp b/source/blender/compositor/operations/COM_ColorCurveOperation.cpp
index 9848d191c04..88bd673a19f 100644
--- a/source/blender/compositor/operations/COM_ColorCurveOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorCurveOperation.cpp
@@ -58,7 +58,7 @@ void ColorCurveOperation::initExecution()
 
 }
 
-void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	CurveMapping *cumap = this->m_curveMapping;
 	CurveMapping *workingCopy = (CurveMapping *)MEM_dupallocN(cumap);
@@ -68,13 +68,13 @@ void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSamp
 	float fac[4];
 	float image[4];
 
-	this->m_inputBlackProgram->read(black, x, y, sampler, inputBuffers);
-	this->m_inputWhiteProgram->read(white, x, y, sampler, inputBuffers);
+	this->m_inputBlackProgram->read(black, x, y, sampler);
+	this->m_inputWhiteProgram->read(white, x, y, sampler);
 
 	curvemapping_set_black_white(workingCopy, black, white);
 
-	this->m_inputFacProgram->read(fac, x, y, sampler, inputBuffers);
-	this->m_inputImageProgram->read(image, x, y, sampler, inputBuffers);
+	this->m_inputFacProgram->read(fac, x, y, sampler);
+	this->m_inputImageProgram->read(image, x, y, sampler);
 
 	if (*fac >= 1.0f)
 		curvemapping_evaluate_premulRGBF(workingCopy, color, image);
@@ -126,14 +126,14 @@ void ConstantLevelColorCurveOperation::initExecution()
 	curvemapping_set_black_white(this->m_curveMapping, this->m_black, this->m_white);
 }
 
-void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float fac[4];
 	float image[4];
 
 
-	this->m_inputFacProgram->read(fac, x, y, sampler, inputBuffers);
-	this->m_inputImageProgram->read(image, x, y, sampler, inputBuffers);
+	this->m_inputFacProgram->read(fac, x, y, sampler);
+	this->m_inputImageProgram->read(image, x, y, sampler);
 
 	if (*fac >= 1.0f)
 		curvemapping_evaluate_premulRGBF(this->m_curveMapping, color, image);
diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.h b/source/blender/compositor/operations/COM_ColorCurveOperation.h
index 3bcbc31650c..beb2e16298a 100644
--- a/source/blender/compositor/operations/COM_ColorCurveOperation.h
+++ b/source/blender/compositor/operations/COM_ColorCurveOperation.h
@@ -41,7 +41,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
@@ -70,7 +70,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.cpp b/source/blender/compositor/operations/COM_ColorMatteOperation.cpp
index 4a01499b060..5326e397494 100644
--- a/source/blender/compositor/operations/COM_ColorMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorMatteOperation.cpp
@@ -44,7 +44,7 @@ void ColorMatteOperation::deinitExecution()
 	this->m_inputKeyProgram = NULL;
 }
 
-void ColorMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inColor[4];
 	float inKey[4];
@@ -55,8 +55,8 @@ void ColorMatteOperation::executePixel(float *outputValue, float x, float y, Pix
 
 	float h_wrap;
 
-	this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers);
-	this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers);
+	this->m_inputImageProgram->read(inColor, x, y, sampler);
+	this->m_inputKeyProgram->read(inKey, x, y, sampler);
 
 
 	/* store matte(alpha) value in [0] to go with
diff --git a/source/blender/compositor/operations/COM_ColorMatteOperation.h b/source/blender/compositor/operations/COM_ColorMatteOperation.h
index d996ce34667..de7c4dd8ce2 100644
--- a/source/blender/compositor/operations/COM_ColorMatteOperation.h
+++ b/source/blender/compositor/operations/COM_ColorMatteOperation.h
@@ -42,7 +42,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.cpp b/source/blender/compositor/operations/COM_ColorRampOperation.cpp
index 95dca0dc410..edd7df89c81 100644
--- a/source/blender/compositor/operations/COM_ColorRampOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorRampOperation.cpp
@@ -43,11 +43,11 @@ void ColorRampOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void ColorRampOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorRampOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float values[4];
 
-	this->m_inputProgram->read(values, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(values, x, y, sampler);
 	do_colorband(this->m_colorBand, values[0], color);
 }
 
diff --git a/source/blender/compositor/operations/COM_ColorRampOperation.h b/source/blender/compositor/operations/COM_ColorRampOperation.h
index 42bc6b943b7..c5f3fe449de 100644
--- a/source/blender/compositor/operations/COM_ColorRampOperation.h
+++ b/source/blender/compositor/operations/COM_ColorRampOperation.h
@@ -38,7 +38,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.cpp b/source/blender/compositor/operations/COM_ColorSpillOperation.cpp
index e2773f3a6b4..2c0bfc10bb0 100644
--- a/source/blender/compositor/operations/COM_ColorSpillOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorSpillOperation.cpp
@@ -84,12 +84,12 @@ void ColorSpillOperation::deinitExecution()
 	this->m_inputFacReader = NULL;
 }
 
-void ColorSpillOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorSpillOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float fac[4];
 	float input[4];
-	this->m_inputFacReader->read(fac, x, y, sampler, inputBuffers);
-	this->m_inputImageReader->read(input, x, y, sampler, inputBuffers);
+	this->m_inputFacReader->read(fac, x, y, sampler);
+	this->m_inputImageReader->read(input, x, y, sampler);
 	float rfac = min(1.0f, fac[0]);
 	float map = calculateMapValue(rfac, input);
 	if (map > 0.0f) {
diff --git a/source/blender/compositor/operations/COM_ColorSpillOperation.h b/source/blender/compositor/operations/COM_ColorSpillOperation.h
index 7aac612cb8c..ea443f2a5a1 100644
--- a/source/blender/compositor/operations/COM_ColorSpillOperation.h
+++ b/source/blender/compositor/operations/COM_ColorSpillOperation.h
@@ -46,7 +46,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp b/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp
index 9f175a381a4..d05040c4c12 100644
--- a/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp
+++ b/source/blender/compositor/operations/COM_CombineChannelsOperation.cpp
@@ -78,24 +78,24 @@ void CombineChannelsOperation::deinitExecution()
 }
 
 
-void CombineChannelsOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void CombineChannelsOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float input[4];
 	/// @todo: remove if statements
 	if (this->m_inputChannel1Operation) {
-		this->m_inputChannel1Operation->read(input, x, y, sampler, inputBuffers);
+		this->m_inputChannel1Operation->read(input, x, y, sampler);
 		color[0] = input[0];
 	}
 	if (this->m_inputChannel2Operation) {
-		this->m_inputChannel2Operation->read(input, x, y, sampler, inputBuffers);
+		this->m_inputChannel2Operation->read(input, x, y, sampler);
 		color[1] = input[0];
 	}
 	if (this->m_inputChannel3Operation) {
-		this->m_inputChannel3Operation->read(input, x, y, sampler, inputBuffers);
+		this->m_inputChannel3Operation->read(input, x, y, sampler);
 		color[2] = input[0];
 	}
 	if (this->m_inputChannel4Operation) {
-		this->m_inputChannel4Operation->read(input, x, y, sampler, inputBuffers);
+		this->m_inputChannel4Operation->read(input, x, y, sampler);
 		color[3] = input[0];
 	}
 }
diff --git a/source/blender/compositor/operations/COM_CombineChannelsOperation.h b/source/blender/compositor/operations/COM_CombineChannelsOperation.h
index 8e4c2120614..ff1251a3949 100644
--- a/source/blender/compositor/operations/COM_CombineChannelsOperation.h
+++ b/source/blender/compositor/operations/COM_CombineChannelsOperation.h
@@ -33,7 +33,7 @@ private:
 	SocketReader *m_inputChannel4Operation;
 public:
 	CombineChannelsOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_CompositorOperation.cpp b/source/blender/compositor/operations/COM_CompositorOperation.cpp
index a58f77386ea..445b0634ced 100644
--- a/source/blender/compositor/operations/COM_CompositorOperation.cpp
+++ b/source/blender/compositor/operations/COM_CompositorOperation.cpp
@@ -111,9 +111,9 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 
 	for (y = y1; y < y2 && (!breaked); y++) {
 		for (x = x1; x < x2 && (!breaked); x++) {
-			this->m_imageInput->read(color, x, y, COM_PS_NEAREST, NULL);
+			this->m_imageInput->read(color, x, y, COM_PS_NEAREST);
 			if (this->m_alphaInput != NULL) {
-				this->m_alphaInput->read(&(color[3]), x, y, COM_PS_NEAREST, NULL);
+				this->m_alphaInput->read(&(color[3]), x, y, COM_PS_NEAREST);
 			}
 			copy_v4_v4(buffer + offset, color);
 			offset += COM_NUMBER_OF_CHANNELS;
diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
index 4d829eae7a0..c7272d461d6 100644
--- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
@@ -38,10 +38,10 @@ void ConvertColorProfileOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorProfileOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorProfileOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float color[4];
-	this->m_inputOperation->read(color, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(color, x, y, sampler);
 	IMB_buffer_float_from_float(outputValue, color, 4, this->m_toProfile, this->m_fromProfile, this->m_predivided, 1, 1, 0, 0);
 }
 
diff --git a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
index b237448d16e..09d96a92d95 100644
--- a/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
@@ -59,7 +59,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp
index a8c57449a2e..4da09a69a15 100644
--- a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp
@@ -34,10 +34,10 @@ void ConvertColorToBWOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorToBWOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorToBWOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(&inputColor[0], x, y, sampler);
 	outputValue[0] = rgb_to_bw(inputColor);
 }
 
diff --git a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h
index 9c62ad8dd39..a9951af2e3b 100644
--- a/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertColorToBWOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertColorToValueProg.cpp b/source/blender/compositor/operations/COM_ConvertColorToValueProg.cpp
index c09842b1aa9..17bd34d51b0 100644
--- a/source/blender/compositor/operations/COM_ConvertColorToValueProg.cpp
+++ b/source/blender/compositor/operations/COM_ConvertColorToValueProg.cpp
@@ -34,10 +34,10 @@ void ConvertColorToValueProg::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorToValueProg::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorToValueProg::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(&inputColor[0], x, y, sampler);
 	outputValue[0] = (inputColor[0] + inputColor[1] + inputColor[2]) / 3.0f;
 }
 
diff --git a/source/blender/compositor/operations/COM_ConvertColorToValueProg.h b/source/blender/compositor/operations/COM_ConvertColorToValueProg.h
index c1ac7ca69ce..6a20d4bf27a 100644
--- a/source/blender/compositor/operations/COM_ConvertColorToValueProg.h
+++ b/source/blender/compositor/operations/COM_ConvertColorToValueProg.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp
index 6c79c4ea6a3..ec1f0fd37e4 100644
--- a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp
@@ -34,9 +34,9 @@ void ConvertColorToVectorOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
-	this->m_inputOperation->read(outputValue, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(outputValue, x, y, sampler);
 }
 
 void ConvertColorToVectorOperation::deinitExecution()
diff --git a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h
index 51fa3a677cd..861807db8db 100644
--- a/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
index b4319d25d13..80416bbccdf 100644
--- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
@@ -75,12 +75,12 @@ void ConvertDepthToRadiusOperation::initExecution()
 	}
 }
 
-void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	float z;
 	float radius;
-	this->m_inputOperation->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputValue, x, y, sampler);
 	z = inputValue[0];
 	if (z != 0.f) {
 		float iZ = (1.f / z);
diff --git a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
index f0e905db9c2..4f80ef69f43 100644
--- a/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
@@ -54,7 +54,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp
index 5149e370208..4b42de26f59 100644
--- a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp
@@ -35,10 +35,10 @@ void ConvertHSVToRGBOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertHSVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertHSVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor, x, y, sampler);
 	hsv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
 	outputValue[3] = inputColor[3];
 }
diff --git a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h
index 3babbfb7c1d..28ce70170a0 100644
--- a/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp
index b7db0a6a2c7..787b1a4547c 100644
--- a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp
@@ -35,12 +35,12 @@ void ConvertKeyToPremulOperation::initExecution()
 	this->m_inputColor = getInputSocketReader(0);
 }
 
-void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	float alpha;
 
-	this->m_inputColor->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputColor->read(inputValue, x, y, sampler);
 	alpha = inputValue[3];
 
 	mul_v3_v3fl(outputValue, inputValue, alpha);
diff --git a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h
index 50b39928305..a1a8836a690 100644
--- a/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h
@@ -40,7 +40,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp
index 0ba23b2ec2e..22cfdd2f572 100644
--- a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp
@@ -35,12 +35,12 @@ void ConvertPremulToKeyOperation::initExecution()
 	this->m_inputColor = getInputSocketReader(0);
 }
 
-void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	float alpha;
 
-	this->m_inputColor->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputColor->read(inputValue, x, y, sampler);
 	alpha = inputValue[3];
 
 	if (fabsf(alpha) < 1e-5f) {
diff --git a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h
index 173cbb4fc0a..fb83a06c25d 100644
--- a/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h
@@ -40,7 +40,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp
index dd5e9907642..8478eac75b0 100644
--- a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp
@@ -35,10 +35,10 @@ void ConvertRGBToHSVOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertRGBToHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertRGBToHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor, x, y, sampler);
 	rgb_to_hsv(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
 	outputValue[3] = inputColor[3];
 }
diff --git a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h
index 42bd439c8c2..09f6c7e48a6 100644
--- a/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp
index 7f41a79b7f4..52aa1d7a123 100644
--- a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp
@@ -50,12 +50,12 @@ void ConvertRGBToYCCOperation::setMode(int mode)
 	}
 }
 
-void ConvertRGBToYCCOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertRGBToYCCOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
 	float color[3];
 
-	this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor, x, y, sampler);
 	rgb_to_ycc(inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], this->m_mode);
 
 	/* divided by 255 to normalize for viewing in */
diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h
index 744e0657dc6..7f4eb6d7318 100644
--- a/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h
@@ -48,7 +48,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp
index e87a765f2eb..2206a066a37 100644
--- a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp
@@ -34,10 +34,10 @@ void ConvertRGBToYUVOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertRGBToYUVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertRGBToYUVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor, x, y, sampler);
 	rgb_to_yuv(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
 	outputValue[3] = inputColor[3];
 }
diff --git a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h
index b470378704e..f7b3da800b3 100644
--- a/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h
@@ -43,7 +43,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertValueToColorProg.cpp b/source/blender/compositor/operations/COM_ConvertValueToColorProg.cpp
index 100a4931d69..330ffd00acb 100644
--- a/source/blender/compositor/operations/COM_ConvertValueToColorProg.cpp
+++ b/source/blender/compositor/operations/COM_ConvertValueToColorProg.cpp
@@ -33,10 +33,10 @@ void ConvertValueToColorProg::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void ConvertValueToColorProg::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertValueToColorProg::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
-	this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(inputValue, x, y, sampler);
 	color[0] = inputValue[0];
 	color[1] = inputValue[0];
 	color[2] = inputValue[0];
diff --git a/source/blender/compositor/operations/COM_ConvertValueToColorProg.h b/source/blender/compositor/operations/COM_ConvertValueToColorProg.h
index d59964dd400..2fa5edcf09b 100644
--- a/source/blender/compositor/operations/COM_ConvertValueToColorProg.h
+++ b/source/blender/compositor/operations/COM_ConvertValueToColorProg.h
@@ -37,7 +37,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp
index 37760fe26d7..54a5b0dbd0e 100644
--- a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp
@@ -34,10 +34,10 @@ void ConvertValueToVectorOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertValueToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertValueToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float input[4];
-	this->m_inputOperation->read(input, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(input, x, y, sampler);
 	outputValue[0] = input[0];
 	outputValue[1] = input[0];
 	outputValue[2] = input[0];
diff --git a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h
index 0e79c1ff3df..c0936a32eb5 100644
--- a/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp
index 395b96e8b25..9fb9a2e0705 100644
--- a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp
@@ -34,9 +34,9 @@ void ConvertVectorToColorOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertVectorToColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertVectorToColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
-	this->m_inputOperation->read(outputValue, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(outputValue, x, y, sampler);
 	outputValue[3] = 1.0f;
 }
 
diff --git a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h
index 8225d03d58e..a062c452a91 100644
--- a/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp
index 68842c5a055..23b552f1dbe 100644
--- a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp
@@ -34,10 +34,10 @@ void ConvertVectorToValueOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertVectorToValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertVectorToValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float input[4];
-	this->m_inputOperation->read(input, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(input, x, y, sampler);
 	outputValue[0] = (input[0] + input[1] + input[2]) / 3.0f;
 }
 
diff --git a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h
index a7981e8dc59..b662f3eed6c 100644
--- a/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp
index 78b7a7af60d..88a7e7dedd9 100644
--- a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp
@@ -50,10 +50,10 @@ void ConvertYCCToRGBOperation::setMode(int mode)
 	}
 }
 
-void ConvertYCCToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertYCCToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor, x, y, sampler);
 
 	/* need to un-normalize the data */
 	/* R,G,B --> Y,Cb,Cr */
diff --git a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h
index e23dfd8a985..a8e03bcb807 100644
--- a/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h
@@ -48,7 +48,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp
index b4393c53b92..1a5e7cbf2a6 100644
--- a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp
@@ -34,10 +34,10 @@ void ConvertYUVToRGBOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertYUVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertYUVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(inputColor, x, y, sampler);
 	yuv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
 	outputValue[3] = inputColor[3];
 }
diff --git a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h
index 3368e0a24df..80321ae37d2 100644
--- a/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h
+++ b/source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h
@@ -43,7 +43,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
index cf3ffe6d8f4..90bda5c8d2c 100644
--- a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
@@ -28,7 +28,7 @@ ConvolutionEdgeFilterOperation::ConvolutionEdgeFilterOperation() : ConvolutionFi
 	/* pass */
 }
 
-void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float in1[4], in2[4], res1[4], res2[4];
 
@@ -46,7 +46,7 @@ void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, Me
 	CLAMP(y3, 0, getHeight() - 1);
 	
 	float value[4];
-	this->m_inputValueOperation->read(value, x2, y2, inputBuffers, NULL);
+	this->m_inputValueOperation->read(value, x2, y2, NULL);
 	float mval = 1.0f - value[0];
 	
 	res1[0] = 0.0f;
@@ -58,39 +58,39 @@ void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, Me
 	res2[2] = 0.0f;
 	res2[3] = 0.0f;
 	
-	this->m_inputOperation->read(in1, x1, y1, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x1, y1, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[0]);
 	madd_v3_v3fl(res2, in1, this->m_filter[0]);
 	
-	this->m_inputOperation->read(in1, x2, y1, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x2, y1, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[1]);
 	madd_v3_v3fl(res2, in1, this->m_filter[3]);
 	
-	this->m_inputOperation->read(in1, x3, y1, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x3, y1, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[2]);
 	madd_v3_v3fl(res2, in1, this->m_filter[6]);
 	
-	this->m_inputOperation->read(in1, x1, y2, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x1, y2, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[3]);
 	madd_v3_v3fl(res2, in1, this->m_filter[1]);
 	
-	this->m_inputOperation->read(in2, x2, y2, inputBuffers, NULL);
+	this->m_inputOperation->read(in2, x2, y2, NULL);
 	madd_v3_v3fl(res1, in2, this->m_filter[4]);
 	madd_v3_v3fl(res2, in2, this->m_filter[4]);
 	
-	this->m_inputOperation->read(in1, x3, y2, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x3, y2, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[5]);
 	madd_v3_v3fl(res2, in1, this->m_filter[7]);
 	
-	this->m_inputOperation->read(in1, x1, y3, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x1, y3, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[6]);
 	madd_v3_v3fl(res2, in1, this->m_filter[2]);
 	
-	this->m_inputOperation->read(in1, x2, y3, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x2, y3, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[7]);
 	madd_v3_v3fl(res2, in1, this->m_filter[5]);
 	
-	this->m_inputOperation->read(in1, x3, y3, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x3, y3, NULL);
 	madd_v3_v3fl(res1, in1, this->m_filter[8]);
 	madd_v3_v3fl(res2, in1, this->m_filter[8]);
 	
diff --git a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h
index 92e45c7104f..b96b8785524 100644
--- a/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h
+++ b/source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h
@@ -28,7 +28,7 @@
 class ConvolutionEdgeFilterOperation : public ConvolutionFilterOperation {
 public:
 	ConvolutionEdgeFilterOperation();
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp
index 3840e775fe3..6c1e434ab41 100644
--- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp
+++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp
@@ -67,7 +67,7 @@ void ConvolutionFilterOperation::deinitExecution()
 }
 
 
-void ConvolutionFilterOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ConvolutionFilterOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float in1[4];
 	float in2[4];
@@ -84,27 +84,27 @@ void ConvolutionFilterOperation::executePixel(float *color, int x, int y, Memory
 	CLAMP(y2, 0, getHeight() - 1);
 	CLAMP(y3, 0, getHeight() - 1);
 	float value[4];
-	this->m_inputValueOperation->read(value, x2, y2, inputBuffers, NULL);
+	this->m_inputValueOperation->read(value, x2, y2, NULL);
 	const float mval = 1.0f - value[0];
 
 	zero_v4(color);
-	this->m_inputOperation->read(in1, x1, y1, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x1, y1, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[0]);
-	this->m_inputOperation->read(in1, x2, y1, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x2, y1, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[1]);
-	this->m_inputOperation->read(in1, x3, y1, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x3, y1, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[2]);
-	this->m_inputOperation->read(in1, x1, y2, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x1, y2, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[3]);
-	this->m_inputOperation->read(in2, x2, y2, inputBuffers, NULL);
+	this->m_inputOperation->read(in2, x2, y2, NULL);
 	madd_v4_v4fl(color, in2, this->m_filter[4]);
-	this->m_inputOperation->read(in1, x3, y2, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x3, y2, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[5]);
-	this->m_inputOperation->read(in1, x1, y3, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x1, y3, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[6]);
-	this->m_inputOperation->read(in1, x2, y3, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x2, y3, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[7]);
-	this->m_inputOperation->read(in1, x3, y3, inputBuffers, NULL);
+	this->m_inputOperation->read(in1, x3, y3, NULL);
 	madd_v4_v4fl(color, in1, this->m_filter[8]);
 	
 	color[0] = color[0] * value[0] + in2[0] * mval;
diff --git a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h
index 0b5dfb4d75a..88455730c0e 100644
--- a/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h
+++ b/source/blender/compositor/operations/COM_ConvolutionFilterOperation.h
@@ -39,7 +39,7 @@ public:
 	ConvolutionFilterOperation();
 	void set3x3Filter(float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9);
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_CropOperation.cpp b/source/blender/compositor/operations/COM_CropOperation.cpp
index 0a40f2370c8..efbc331e7d3 100644
--- a/source/blender/compositor/operations/COM_CropOperation.cpp
+++ b/source/blender/compositor/operations/COM_CropOperation.cpp
@@ -73,10 +73,10 @@ CropOperation::CropOperation() : CropBaseOperation()
 	/* pass */
 }
 
-void CropOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void CropOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	if ((x < this->m_xmax && x >= this->m_xmin) && (y < this->m_ymax && y >= this->m_ymin)) {
-		this->m_inputOperation->read(color, x, y, sampler, inputBuffers);
+		this->m_inputOperation->read(color, x, y, sampler);
 	}
 	else {
 		zero_v4(color);
@@ -108,7 +108,7 @@ void CropImageOperation::determineResolution(unsigned int resolution[], unsigned
 	resolution[1] = this->m_ymax - this->m_ymin;
 }
 
-void CropImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void CropImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
-	this->m_inputOperation->read(color, (x + this->m_xmin), (y + this->m_ymin), sampler, inputBuffers);
+	this->m_inputOperation->read(color, (x + this->m_xmin), (y + this->m_ymin), sampler);
 }
diff --git a/source/blender/compositor/operations/COM_CropOperation.h b/source/blender/compositor/operations/COM_CropOperation.h
index 39dbb8aa873..78644536143 100644
--- a/source/blender/compositor/operations/COM_CropOperation.h
+++ b/source/blender/compositor/operations/COM_CropOperation.h
@@ -48,7 +48,7 @@ class CropOperation : public CropBaseOperation {
 private:
 public:
 	CropOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 class CropImageOperation : public CropBaseOperation {
@@ -57,7 +57,7 @@ public:
 	CropImageOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 	void determineResolution(unsigned int resolution[], unsigned int preferedResolution[]);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
index 3c4bdfe8e5b..ed3799fff5e 100644
--- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
@@ -44,7 +44,7 @@ void DifferenceMatteOperation::deinitExecution()
 	this->m_inputImage2Program = NULL;
 }
 
-void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inColor1[4];
 	float inColor2[4];
@@ -54,8 +54,8 @@ void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y
 	float difference;
 	float alpha;
 
-	this->m_inputImage1Program->read(inColor1, x, y, sampler, inputBuffers);
-	this->m_inputImage2Program->read(inColor2, x, y, sampler, inputBuffers);
+	this->m_inputImage1Program->read(inColor1, x, y, sampler);
+	this->m_inputImage2Program->read(inColor2, x, y, sampler);
 
 	difference = (fabsf(inColor2[0] - inColor1[0]) +
 	              fabsf(inColor2[1] - inColor1[1]) +
diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h
index c35550560e1..acec6ebf193 100644
--- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.h
+++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.h
@@ -43,7 +43,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.cpp b/source/blender/compositor/operations/COM_DilateErodeOperation.cpp
index a9b40f8a6ac..71be94bf2a7 100644
--- a/source/blender/compositor/operations/COM_DilateErodeOperation.cpp
+++ b/source/blender/compositor/operations/COM_DilateErodeOperation.cpp
@@ -54,13 +54,13 @@ void DilateErodeThresholdOperation::initExecution()
 	}
 }
 
-void *DilateErodeThresholdOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DilateErodeThresholdOperation::initializeTileData(rcti *rect)
 {
-	void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+	void *buffer = this->m_inputProgram->initializeTileData(NULL);
 	return buffer;
 }
 
-void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float inputValue[4];
 	const float sw = this->m__switch;
@@ -80,7 +80,7 @@ void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, Mem
 	const int bufferWidth = rect->xmax - rect->xmin;
 	int offset;
 
-	this->m_inputProgram->read(inputValue, x, y, inputBuffers, NULL);
+	this->m_inputProgram->read(inputValue, x, y, NULL);
 	if (inputValue[0] > sw) {
 		for (int yi = miny; yi < maxy; yi++) {
 			const float dy = yi - y;
@@ -179,13 +179,13 @@ void DilateDistanceOperation::initExecution()
 	}
 }
 
-void *DilateDistanceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DilateDistanceOperation::initializeTileData(rcti *rect)
 {
-	void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+	void *buffer = this->m_inputProgram->initializeTileData(NULL);
 	return buffer;
 }
 
-void DilateDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DilateDistanceOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const float distance = this->m_distance;
 	const float mindist = distance * distance;
@@ -259,7 +259,7 @@ ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation()
 	/* pass */
 }
 
-void ErodeDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ErodeDistanceOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const float distance = this->m_distance;
 	const float mindist = distance * distance;
@@ -325,14 +325,14 @@ void DilateStepOperation::initExecution()
 	this->initMutex();
 }
 
-void *DilateStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DilateStepOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_cached_buffer != NULL) {
 		return this->m_cached_buffer;
 	}
 	lockMutex();
 	if (this->m_cached_buffer == NULL) {
-		MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+		MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL);
 		float *rectf = buffer->convertToValueBuffer();
 		int x, y, i;
 		float *p;
@@ -374,7 +374,7 @@ void *DilateStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryB
 }
 
 
-void DilateStepOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DilateStepOperation::executePixel(float *color, int x, int y, void *data)
 {
 	color[0] = this->m_cached_buffer[y * this->getWidth() + x];
 }
@@ -412,14 +412,14 @@ ErodeStepOperation::ErodeStepOperation() : DilateStepOperation()
 	/* pass */
 }
 
-void *ErodeStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *ErodeStepOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_cached_buffer != NULL) {
 		return this->m_cached_buffer;
 	}
 	lockMutex();
 	if (this->m_cached_buffer == NULL) {
-		MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+		MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL);
 		float *rectf = buffer->convertToValueBuffer();
 		int x, y, i;
 		float *p;
diff --git a/source/blender/compositor/operations/COM_DilateErodeOperation.h b/source/blender/compositor/operations/COM_DilateErodeOperation.h
index bc6049bf992..8c3eefb97e4 100644
--- a/source/blender/compositor/operations/COM_DilateErodeOperation.h
+++ b/source/blender/compositor/operations/COM_DilateErodeOperation.h
@@ -47,14 +47,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * Deinitialize the execution
 	 */
@@ -83,14 +83,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * Deinitialize the execution
 	 */
@@ -111,7 +111,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 
 	void executeOpenCL(OpenCLDevice* device,
 	                   MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer, 
@@ -135,14 +135,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * Deinitialize the execution
 	 */
@@ -157,7 +157,7 @@ class ErodeStepOperation : public DilateStepOperation {
 public:
 	ErodeStepOperation();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
index 76ee5b2c2a1..5e6ff2c7da1 100644
--- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
@@ -66,12 +66,12 @@ void DirectionalBlurOperation::initExecution()
 
 }
 
-void DirectionalBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DirectionalBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const int iterations = pow(2.0f, this->m_data->iter);
 	float col[4] = {0, 0, 0, 0};
 	float col2[4] = {0, 0, 0, 0};
-	this->m_inputProgram->read(col2, x, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputProgram->read(col2, x, y, COM_PS_NEAREST);
 	float ltx = this->m_tx;
 	float lty = this->m_ty;
 	float lsc = this->m_sc;
@@ -87,7 +87,7 @@ void DirectionalBlurOperation::executePixel(float *color, int x, int y, MemoryBu
 		this->m_inputProgram->read(col,
 		                           cs * u + ss * v + this->m_center_x_pix,
 		                           cs * v - ss * u + this->m_center_y_pix,
-		                           COM_PS_NEAREST, inputBuffers);
+		                           COM_PS_NEAREST);
 
 		add_v4_v4(col2, col);
 
diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h
index 0ab5e9dff2d..cc49e947f95 100644
--- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.h
+++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.h
@@ -40,7 +40,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.cpp b/source/blender/compositor/operations/COM_DisplaceOperation.cpp
index 3ef73feaf36..018df78cb65 100644
--- a/source/blender/compositor/operations/COM_DisplaceOperation.cpp
+++ b/source/blender/compositor/operations/COM_DisplaceOperation.cpp
@@ -54,7 +54,7 @@ void DisplaceOperation::initExecution()
  * in order to take effect */
 #define DISPLACE_EPSILON    0.01f
 
-void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DisplaceOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float inVector[4];
 	float inScale[4];
@@ -64,9 +64,9 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
 	float dxt, dyt;
 	float u, v;
 
-	this->m_inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST);
 	float xs = inScale[0];
-	this->m_inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST);
 	float ys = inScale[0];
 
 	/* clamp x and y displacement to triple image resolution - 
@@ -74,7 +74,7 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
 	CLAMP(xs, -this->m_width_x4, this->m_width_x4);
 	CLAMP(ys, -this->m_height_x4, this->m_height_x4);
 
-	this->m_inputVectorProgram->read(inVector, x, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputVectorProgram->read(inVector, x, y, COM_PS_NEAREST);
 	p_dx = inVector[0] * xs;
 	p_dy = inVector[1] * ys;
 
@@ -83,9 +83,9 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
 	v = y - p_dy + 0.5f;
 
 	/* calc derivatives */
-	this->m_inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST);
 	d_dx = inVector[0] * xs;
-	this->m_inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST, inputBuffers);
+	this->m_inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST);
 	d_dy = inVector[1] * ys;
 
 	/* clamp derivatives to minimum displacement distance in UV space */
@@ -96,7 +96,7 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
 	dyt = signf(dyt) * maxf(fabsf(dyt), DISPLACE_EPSILON) / this->getHeight();
 
 	/* EWA filtering */
-	this->m_inputColorProgram->read(color, u, v, dxt, dyt, inputBuffers);
+	this->m_inputColorProgram->read(color, u, v, dxt, dyt);
 }
 
 void DisplaceOperation::deinitExecution()
diff --git a/source/blender/compositor/operations/COM_DisplaceOperation.h b/source/blender/compositor/operations/COM_DisplaceOperation.h
index e01c9190396..0e5b042aea5 100644
--- a/source/blender/compositor/operations/COM_DisplaceOperation.h
+++ b/source/blender/compositor/operations/COM_DisplaceOperation.h
@@ -48,7 +48,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
index d21fc62abd7..a93e39085c5 100644
--- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
+++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
@@ -53,7 +53,7 @@ void DisplaceSimpleOperation::initExecution()
  * in order to take effect */
 #define DISPLACE_EPSILON    0.01f
 
-void DisplaceSimpleOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DisplaceSimpleOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inVector[4];
 	float inScale[4];
@@ -61,9 +61,9 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel
 	float p_dx, p_dy;   /* main displacement in pixel space */
 	float u, v;
 
-	this->m_inputScaleXProgram->read(inScale, x, y, sampler, inputBuffers);
+	this->m_inputScaleXProgram->read(inScale, x, y, sampler);
 	float xs = inScale[0];
-	this->m_inputScaleYProgram->read(inScale, x, y, sampler, inputBuffers);
+	this->m_inputScaleYProgram->read(inScale, x, y, sampler);
 	float ys = inScale[0];
 
 	/* clamp x and y displacement to triple image resolution - 
@@ -71,7 +71,7 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel
 	CLAMP(xs, -this->m_width_x4, this->m_width_x4);
 	CLAMP(ys, -this->m_height_x4, this->m_height_x4);
 
-	this->m_inputVectorProgram->read(inVector, x, y, sampler, inputBuffers);
+	this->m_inputVectorProgram->read(inVector, x, y, sampler);
 	p_dx = inVector[0] * xs;
 	p_dy = inVector[1] * ys;
 
@@ -82,7 +82,7 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel
 	CLAMP(u, 0.f, this->getWidth() - 1.f);
 	CLAMP(v, 0.f, this->getHeight() - 1.f);
 
-	this->m_inputColorProgram->read(color, u, v, sampler, inputBuffers);
+	this->m_inputColorProgram->read(color, u, v, sampler);
 }
 
 void DisplaceSimpleOperation::deinitExecution()
diff --git a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
index 25afbafe335..81adc7be366 100644
--- a/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
+++ b/source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
@@ -48,7 +48,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp b/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
index 5bdc616fed7..197e8b07918 100644
--- a/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
@@ -44,7 +44,7 @@ void DistanceMatteOperation::deinitExecution()
 	this->m_inputKeyProgram = NULL;
 }
 
-void DistanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DistanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inKey[4];
 	float inImage[4];
@@ -55,8 +55,8 @@ void DistanceMatteOperation::executePixel(float *outputValue, float x, float y,
 	float distance;
 	float alpha;
 
-	this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers);
-	this->m_inputImageProgram->read(inImage, x, y, sampler, inputBuffers);
+	this->m_inputKeyProgram->read(inKey, x, y, sampler);
+	this->m_inputImageProgram->read(inImage, x, y, sampler);
 	
 	distance = sqrt(pow((inKey[0] - inImage[0]), 2) +
 	                pow((inKey[1] - inImage[1]), 2) +
diff --git a/source/blender/compositor/operations/COM_DistanceMatteOperation.h b/source/blender/compositor/operations/COM_DistanceMatteOperation.h
index 267aa1fca7a..6fe16c7fdff 100644
--- a/source/blender/compositor/operations/COM_DistanceMatteOperation.h
+++ b/source/blender/compositor/operations/COM_DistanceMatteOperation.h
@@ -42,7 +42,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_DotproductOperation.cpp b/source/blender/compositor/operations/COM_DotproductOperation.cpp
index 53ab5f97518..559d97d6056 100644
--- a/source/blender/compositor/operations/COM_DotproductOperation.cpp
+++ b/source/blender/compositor/operations/COM_DotproductOperation.cpp
@@ -45,11 +45,11 @@ void DotproductOperation::deinitExecution()
 
 /** @todo: current implementation is the inverse of a dotproduct. not 'logically' correct
  */
-void DotproductOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DotproductOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float input1[4];
 	float input2[4];
-	this->m_input1Operation->read(input1, x, y, sampler, inputBuffers);
-	this->m_input2Operation->read(input2, x, y, sampler, inputBuffers);
+	this->m_input1Operation->read(input1, x, y, sampler);
+	this->m_input2Operation->read(input2, x, y, sampler);
 	color[0] = -(input1[0] * input2[0] + input1[1] * input2[1] + input1[2] * input2[2]);
 }
diff --git a/source/blender/compositor/operations/COM_DotproductOperation.h b/source/blender/compositor/operations/COM_DotproductOperation.h
index 7ca540983d9..6ff6f622a50 100644
--- a/source/blender/compositor/operations/COM_DotproductOperation.h
+++ b/source/blender/compositor/operations/COM_DotproductOperation.h
@@ -31,7 +31,7 @@ private:
 	SocketReader *m_input2Operation;
 public:
 	DotproductOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
index e5a145bab2e..bcad974da70 100644
--- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
@@ -1260,15 +1260,15 @@ void DoubleEdgeMaskOperation::initExecution()
 	this->m_cachedInstance = NULL;
 }
 
-void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_cachedInstance)
 		return this->m_cachedInstance;
 	
 	lockMutex();
 	if (this->m_cachedInstance == NULL) {
-		MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect, memoryBuffers);
-		MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect);
+		MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect);
 		float *data = new float[this->getWidth() * this->getHeight()];
 		float *imask = innerMask->convertToValueBuffer();
 		float *omask = outerMask->convertToValueBuffer();
@@ -1280,7 +1280,7 @@ void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **mem
 	unlockMutex();
 	return this->m_cachedInstance;
 }
-void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float *buffer = (float *) data;
 	int index = (y * this->getWidth() + x);
diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
index 442680e320e..32e5a07cfdc 100644
--- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
+++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
@@ -42,7 +42,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
@@ -54,7 +54,7 @@ public:
 	 */
 	void deinitExecution();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 	
diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp b/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
index 1aa1b89ee76..c3cbaaaf2fc 100644
--- a/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
@@ -44,7 +44,7 @@ void EllipseMaskOperation::initExecution()
 	this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight();
 }
 
-void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputMask[4];
 	float inputValue[4];
@@ -57,8 +57,8 @@ void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSam
 	rx = this->m_data->x + (this->m_cosine * dx + this->m_sine * dy);
 	ry = this->m_data->y + (-this->m_sine * dx + this->m_cosine * dy);
 	
-	this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers);
-	this->m_inputValue->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputMask->read(inputMask, x, y, sampler);
+	this->m_inputValue->read(inputValue, x, y, sampler);
 	
 	const float halfHeight = (this->m_data->height) / 2.0f;
 	const float halfWidth = this->m_data->width / 2.0f;
diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.h b/source/blender/compositor/operations/COM_EllipseMaskOperation.h
index 0b0ffa023cb..fce3c93bba6 100644
--- a/source/blender/compositor/operations/COM_EllipseMaskOperation.h
+++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.h
@@ -45,7 +45,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
index 6d9c980ea58..7ef363f5c4a 100644
--- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
@@ -31,7 +31,7 @@ FastGaussianBlurOperation::FastGaussianBlurOperation() : BlurBaseOperation(COM_D
 	this->m_iirgaus = NULL;
 }
 
-void FastGaussianBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void FastGaussianBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	MemoryBuffer *newData = (MemoryBuffer *)data;
 	newData->read(color, x, y);	
@@ -79,13 +79,13 @@ void FastGaussianBlurOperation::deinitExecution()
 	BlurBaseOperation::deinitMutex();
 }
 
-void *FastGaussianBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *FastGaussianBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_iirgaus) {
-		MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect);
 		MemoryBuffer *copy = newBuf->duplicate();
-		updateSize(memoryBuffers);
+		updateSize();
 
 		int c;
 		this->m_sx = this->m_data->sizex * this->m_size / 2.0f;
@@ -233,7 +233,7 @@ FastGaussianBlurValueOperation::FastGaussianBlurValueOperation() : NodeOperation
 	setComplex(true);
 }
 
-void FastGaussianBlurValueOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void FastGaussianBlurValueOperation::executePixel(float *color, int x, int y, void *data)
 {
 	MemoryBuffer *newData = (MemoryBuffer *)data;
 	newData->read(color, x, y);	
@@ -270,11 +270,11 @@ void FastGaussianBlurValueOperation::deinitExecution()
 	deinitMutex();
 }
 
-void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_iirgaus) {
-		MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputprogram->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputprogram->initializeTileData(rect);
 		MemoryBuffer *copy = newBuf->duplicate();
 		FastGaussianBlurOperation::IIR_gauss(copy, this->m_sigma, 0, 3);
 		this->m_iirgaus = copy;
diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
index 5f76490473f..4560e1b25e3 100644
--- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
+++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
@@ -34,10 +34,10 @@ private:
 public:
 	FastGaussianBlurOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	static void IIR_gauss(MemoryBuffer *src, float sigma, unsigned int channel, unsigned int xy);
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	void deinitExecution();
 	void initExecution();
 };
@@ -50,9 +50,9 @@ private:
 public:
 	FastGaussianBlurValueOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	void deinitExecution();
 	void initExecution();
 	void setSigma(float sigma) { this->m_sigma = sigma; }
diff --git a/source/blender/compositor/operations/COM_FlipOperation.cpp b/source/blender/compositor/operations/COM_FlipOperation.cpp
index 60dabb86bb5..939d05fffbf 100644
--- a/source/blender/compositor/operations/COM_FlipOperation.cpp
+++ b/source/blender/compositor/operations/COM_FlipOperation.cpp
@@ -42,12 +42,12 @@ void FlipOperation::deinitExecution()
 }
 
 
-void FlipOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void FlipOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float nx = this->m_flipX ? this->getWidth() - 1 - x : x;
 	float ny = this->m_flipY ? this->getHeight() - 1 - y : y;
 	
-	this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers);
+	this->m_inputOperation->read(color, nx, ny, sampler);
 }
 
 bool FlipOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
diff --git a/source/blender/compositor/operations/COM_FlipOperation.h b/source/blender/compositor/operations/COM_FlipOperation.h
index 5442774c94c..a13f7ecf752 100644
--- a/source/blender/compositor/operations/COM_FlipOperation.h
+++ b/source/blender/compositor/operations/COM_FlipOperation.h
@@ -33,7 +33,7 @@ private:
 public:
 	FlipOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp b/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
index db8d54a2f3c..a4cc03ac380 100644
--- a/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
+++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
@@ -34,10 +34,10 @@ void GammaCorrectOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GammaCorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GammaCorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputProgram->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(inputColor, x, y, sampler);
 	if (inputColor[3] > 0.0f) {
 		inputColor[0] /= inputColor[3];
 		inputColor[1] /= inputColor[3];
@@ -75,10 +75,10 @@ void GammaUncorrectOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GammaUncorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GammaUncorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputColor[4];
-	this->m_inputProgram->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(inputColor, x, y, sampler);
 
 	if (inputColor[3] > 0.0f) {
 		inputColor[0] /= inputColor[3];
diff --git a/source/blender/compositor/operations/COM_GammaCorrectOperation.h b/source/blender/compositor/operations/COM_GammaCorrectOperation.h
index 4db911bb9b5..2d4f2ea89d9 100644
--- a/source/blender/compositor/operations/COM_GammaCorrectOperation.h
+++ b/source/blender/compositor/operations/COM_GammaCorrectOperation.h
@@ -38,7 +38,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
@@ -64,7 +64,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_GammaOperation.cpp b/source/blender/compositor/operations/COM_GammaOperation.cpp
index 9ccc76f4392..40c2ee0a1d4 100644
--- a/source/blender/compositor/operations/COM_GammaOperation.cpp
+++ b/source/blender/compositor/operations/COM_GammaOperation.cpp
@@ -37,13 +37,13 @@ void GammaOperation::initExecution()
 	this->m_inputGammaProgram = this->getInputSocketReader(1);
 }
 
-void GammaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GammaOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	float inputGamma[4];
 	
-	this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputGammaProgram->read(inputGamma, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(inputValue, x, y, sampler);
+	this->m_inputGammaProgram->read(inputGamma, x, y, sampler);
 	const float gamma = inputGamma[0];
 	/* check for negative to avoid nan's */
 	color[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0];
diff --git a/source/blender/compositor/operations/COM_GammaOperation.h b/source/blender/compositor/operations/COM_GammaOperation.h
index 758f7bda04d..8fc2599cba9 100644
--- a/source/blender/compositor/operations/COM_GammaOperation.h
+++ b/source/blender/compositor/operations/COM_GammaOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
index a138d4be1d9..9865c87cb07 100644
--- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
@@ -34,13 +34,13 @@ GaussianAlphaXBlurOperation::GaussianAlphaXBlurOperation() : BlurBaseOperation(C
 	this->m_rad = 0;
 }
 
-void *GaussianAlphaXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianAlphaXBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_sizeavailable) {
-		updateGauss(memoryBuffers);
+		updateGauss();
 	}
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	unlockMutex();
 	return buffer;
 }
@@ -62,10 +62,10 @@ void GaussianAlphaXBlurOperation::initExecution()
 	}
 }
 
-void GaussianAlphaXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianAlphaXBlurOperation::updateGauss()
 {
 	if (this->m_gausstab == NULL) {
-		updateSize(memoryBuffers);
+		updateSize();
 		float rad = this->m_size * this->m_data->sizex;
 		if (rad < 1)
 			rad = 1;
@@ -75,7 +75,7 @@ void GaussianAlphaXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
 	}
 
 	if (this->m_distbuf_inv == NULL) {
-		updateSize(memoryBuffers);
+		updateSize();
 		float rad = this->m_size * this->m_data->sizex;
 		if (rad < 1)
 			rad = 1;
@@ -90,7 +90,7 @@ BLI_INLINE float finv_test(const float f, const bool test)
 	return (LIKELY(test == false)) ? f : 1.0f - f;
 }
 
-void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const bool do_invert = this->m_do_subtract;
 	MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
diff --git a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
index 59797c27952..6ea8b7e4371 100644
--- a/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
+++ b/source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
@@ -33,14 +33,14 @@ private:
 	int m_falloff;  /* falloff for distbuf_inv */
 	bool m_do_subtract;
 	int m_rad;
-	void updateGauss(MemoryBuffer **memoryBuffers);
+	void updateGauss();
 public:
 	GaussianAlphaXBlurOperation();
 
 	/**
 	 * @brief the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * @brief initialize the execution
@@ -52,7 +52,7 @@ public:
 	 */
 	void deinitExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
 	/**
diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
index ab5f8d33850..323a381c869 100644
--- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
@@ -34,13 +34,13 @@ GaussianAlphaYBlurOperation::GaussianAlphaYBlurOperation() : BlurBaseOperation(C
 	this->m_rad = 0;
 }
 
-void *GaussianAlphaYBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianAlphaYBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_sizeavailable) {
-		updateGauss(memoryBuffers);
+		updateGauss();
 	}
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	unlockMutex();
 	return buffer;
 }
@@ -62,10 +62,10 @@ void GaussianAlphaYBlurOperation::initExecution()
 	}
 }
 
-void GaussianAlphaYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianAlphaYBlurOperation::updateGauss()
 {
 	if (this->m_gausstab == NULL) {
-		updateSize(memoryBuffers);
+		updateSize();
 		float rad = this->m_size * this->m_data->sizey;
 		if (rad < 1)
 			rad = 1;
@@ -75,7 +75,7 @@ void GaussianAlphaYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
 	}
 
 	if (this->m_distbuf_inv == NULL) {
-		updateSize(memoryBuffers);
+		updateSize();
 		float rad = this->m_size * this->m_data->sizex;
 		if (rad < 1)
 			rad = 1;
@@ -90,7 +90,7 @@ BLI_INLINE float finv_test(const float f, const bool test)
 	return (LIKELY(test == false)) ? f : 1.0f - f;
 }
 
-void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const bool do_invert = this->m_do_subtract;
 	MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
diff --git a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
index e0789db7815..050b0c384cb 100644
--- a/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
+++ b/source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
@@ -33,14 +33,14 @@ private:
 	bool m_do_subtract;
 	int m_falloff;
 	int m_rad;
-	void updateGauss(MemoryBuffer **memoryBuffers);
+	void updateGauss();
 public:
 	GaussianAlphaYBlurOperation();
 	
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * @brief initialize the execution
@@ -52,7 +52,7 @@ public:
 	 */
 	void deinitExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
 	/**
diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
index a9e8de25297..d3c4ad96df0 100644
--- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
@@ -32,13 +32,13 @@ GaussianBokehBlurOperation::GaussianBokehBlurOperation() : BlurBaseOperation(COM
 	this->m_gausstab = NULL;
 }
 
-void *GaussianBokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianBokehBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_sizeavailable) {
-		updateGauss(memoryBuffers);
+		updateGauss();
 	}
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	unlockMutex();
 	return buffer;
 }
@@ -50,11 +50,11 @@ void GaussianBokehBlurOperation::initExecution()
 	initMutex();
 
 	if (this->m_sizeavailable) {
-		updateGauss(NULL);
+		updateGauss();
 	}
 }
 
-void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianBokehBlurOperation::updateGauss()
 {
 	if (this->m_gausstab == NULL) {
 		float radxf;
@@ -67,7 +67,7 @@ void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
 		const float width = this->getWidth();
 		const float height = this->getHeight();
 		if (!this->m_sizeavailable) {
-			updateSize(memoryBuffers);
+			updateSize();
 		}
 		radxf = this->m_size * (float)this->m_data->sizex;
 		if (radxf > width / 2.0f)
@@ -112,7 +112,7 @@ void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
 	}
 }
 
-void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float tempColor[4];
 	tempColor[0] = 0;
@@ -207,9 +207,9 @@ GaussianBokehBlurReferenceOperation::GaussianBokehBlurReferenceOperation() : Nod
 	this->m_inputSize = NULL;
 }
 
-void *GaussianBokehBlurReferenceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianBokehBlurReferenceOperation::initializeTileData(rcti *rect)
 {
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	return buffer;
 }
 
@@ -263,7 +263,7 @@ void GaussianBokehBlurReferenceOperation::updateGauss()
 	this->m_gausstab = ddgauss;
 }
 
-void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float tempColor[4];
 	float tempSize[4];
@@ -277,14 +277,14 @@ void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int
 	int bufferwidth = inputBuffer->getWidth();
 	int bufferstartx = inputBuffer->getRect()->xmin;
 	int bufferstarty = inputBuffer->getRect()->ymin;
-	this->m_inputSize->read(tempSize, x, y, inputBuffers, data);
+	this->m_inputSize->read(tempSize, x, y, data);
 	float size = tempSize[0];
 	CLAMP(size, 0.0f, 1.0f);
 	float sizeX = ceil(this->m_data->sizex * size);
 	float sizeY = ceil(this->m_data->sizey * size);
 
 	if (sizeX <= 0.5f && sizeY <= 0.5f) {
-		this->m_inputImage->read(color, x, y, inputBuffers, data);
+		this->m_inputImage->read(color, x, y, data);
 		return;
 	}
 	
diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
index ea3da65cbd9..1a134c20e63 100644
--- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
+++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
@@ -30,16 +30,16 @@ class GaussianBokehBlurOperation : public BlurBaseOperation {
 private:
 	float *m_gausstab;
 	int m_radx, m_rady;
-	void updateGauss(MemoryBuffer **memoryBuffers);
+	void updateGauss();
 
 public:
 	GaussianBokehBlurOperation();
 	void initExecution();
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Deinitialize the execution
@@ -66,11 +66,11 @@ private:
 public:
 	GaussianBokehBlurReferenceOperation();
 	void initExecution();
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Deinitialize the execution
diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
index 70148da46db..1acd9f21b1a 100644
--- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
@@ -33,13 +33,13 @@ GaussianXBlurOperation::GaussianXBlurOperation() : BlurBaseOperation(COM_DT_COLO
 	this->m_rad = 0;
 }
 
-void *GaussianXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianXBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_sizeavailable) {
-		updateGauss(memoryBuffers);
+		updateGauss();
 	}
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	unlockMutex();
 	return buffer;
 }
@@ -60,10 +60,10 @@ void GaussianXBlurOperation::initExecution()
 	}
 }
 
-void GaussianXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianXBlurOperation::updateGauss()
 {
 	if (this->m_gausstab == NULL) {
-		updateSize(memoryBuffers);
+		updateSize();
 		float rad = this->m_size * this->m_data->sizex;
 		if (rad < 1)
 			rad = 1;
@@ -73,7 +73,7 @@ void GaussianXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
 	}
 }
 
-void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianXBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 	float multiplier_accum = 0.0f;
diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h
index 9b5c2131b74..a4a0dc655e2 100644
--- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.h
+++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.h
@@ -29,14 +29,14 @@ class GaussianXBlurOperation : public BlurBaseOperation {
 private:
 	float *m_gausstab;
 	int m_rad;
-	void updateGauss(MemoryBuffer **memoryBuffers);
+	void updateGauss();
 public:
 	GaussianXBlurOperation();
 
 	/**
 	 * @brief the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * @brief initialize the execution
@@ -48,7 +48,7 @@ public:
 	 */
 	void deinitExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
index 478495ec3be..7ed455a1156 100644
--- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
@@ -33,13 +33,13 @@ GaussianYBlurOperation::GaussianYBlurOperation() : BlurBaseOperation(COM_DT_COLO
 	this->m_rad = 0;
 }
 
-void *GaussianYBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianYBlurOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (!this->m_sizeavailable) {
-		updateGauss(memoryBuffers);
+		updateGauss();
 	}
-	void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(NULL);
 	unlockMutex();
 	return buffer;
 }
@@ -60,10 +60,10 @@ void GaussianYBlurOperation::initExecution()
 	}
 }
 
-void GaussianYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianYBlurOperation::updateGauss()
 {
 	if (this->m_gausstab == NULL) {
-		updateSize(memoryBuffers);
+		updateSize();
 		float rad = this->m_size * this->m_data->sizey;
 		if (rad < 1)
 			rad = 1;
@@ -73,7 +73,7 @@ void GaussianYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
 	}
 }
 
-void GaussianYBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianYBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 	float multiplier_accum = 0.0f;
diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h
index f4d40c231dc..e3e0d8891d3 100644
--- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.h
+++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.h
@@ -29,14 +29,14 @@ class GaussianYBlurOperation : public BlurBaseOperation {
 private:
 	float *m_gausstab;
 	int m_rad;
-	void updateGauss(MemoryBuffer **memoryBuffers);
+	void updateGauss();
 public:
 	GaussianYBlurOperation();
 	
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * @brief initialize the execution
@@ -48,7 +48,7 @@ public:
 	 */
 	void deinitExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_GlareBaseOperation.cpp b/source/blender/compositor/operations/COM_GlareBaseOperation.cpp
index a6678fdecef..8bfc3e436df 100644
--- a/source/blender/compositor/operations/COM_GlareBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_GlareBaseOperation.cpp
@@ -41,9 +41,9 @@ void GlareBaseOperation::deinitExecution()
 	SingleThreadedNodeOperation::deinitExecution();
 }
 
-MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2, MemoryBuffer **memoryBuffers)
+MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2)
 {
-	MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect2, memoryBuffers);
+	MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect2);
 	rcti rect;
 	rect.xmin = 0;
 	rect.ymin = 0;
diff --git a/source/blender/compositor/operations/COM_GlareBaseOperation.h b/source/blender/compositor/operations/COM_GlareBaseOperation.h
index 6104ec7a81e..f6a8f6879da 100644
--- a/source/blender/compositor/operations/COM_GlareBaseOperation.h
+++ b/source/blender/compositor/operations/COM_GlareBaseOperation.h
@@ -68,7 +68,7 @@ protected:
 
 	virtual void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) = 0;
 
-	MemoryBuffer *createMemoryBuffer(rcti *rect, MemoryBuffer **memoryBuffers);
+	MemoryBuffer *createMemoryBuffer(rcti *rect);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp b/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
index 6d8c567c1b5..7f32618d2af 100644
--- a/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
+++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
@@ -42,11 +42,11 @@ void GlareThresholdOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GlareThresholdOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GlareThresholdOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	const float threshold = this->m_settings->threshold;
 	
-	this->m_inputProgram->read(color, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(color, x, y, sampler);
 	if (rgb_to_luma_y(color) >= threshold) {
 		color[0] -= threshold, color[1] -= threshold, color[2] -= threshold;
 		color[0] = MAX2(color[0], 0.0f);
diff --git a/source/blender/compositor/operations/COM_GlareThresholdOperation.h b/source/blender/compositor/operations/COM_GlareThresholdOperation.h
index d89f3a0f29d..faba6c6c47c 100644
--- a/source/blender/compositor/operations/COM_GlareThresholdOperation.h
+++ b/source/blender/compositor/operations/COM_GlareThresholdOperation.h
@@ -42,7 +42,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
index 02914487072..df3d00278c3 100644
--- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
+++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
@@ -45,11 +45,11 @@ void HueSaturationValueCorrectOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void HueSaturationValueCorrectOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void HueSaturationValueCorrectOperation::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
 	float hsv[4], f;
 
-	this->m_inputProgram->read(hsv, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(hsv, x, y, sampler);
 
 	/* adjust hue, scaling returned default 0.5 up to 1 */
 	f = curvemapping_evaluateF(this->m_curveMapping, 0, hsv[0]);
diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
index 7ae5f53e370..ba565a9f752 100644
--- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
+++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
@@ -37,7 +37,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *Vector, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *Vector, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.cpp b/source/blender/compositor/operations/COM_IDMaskOperation.cpp
index c84124368be..daa2ac9299e 100644
--- a/source/blender/compositor/operations/COM_IDMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_IDMaskOperation.cpp
@@ -33,11 +33,11 @@ void IDMaskOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void IDMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void IDMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	
-	this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(inputValue, x, y, sampler);
 	const float a = (inputValue[0] == this->m_objectIndex) ? 1.0f : 0.0f;
 	color[0] = a;
 }
diff --git a/source/blender/compositor/operations/COM_IDMaskOperation.h b/source/blender/compositor/operations/COM_IDMaskOperation.h
index 23e8ec704e8..9d356536499 100644
--- a/source/blender/compositor/operations/COM_IDMaskOperation.h
+++ b/source/blender/compositor/operations/COM_IDMaskOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ImageOperation.cpp b/source/blender/compositor/operations/COM_ImageOperation.cpp
index eb2eaa8167a..729b3f8f18f 100644
--- a/source/blender/compositor/operations/COM_ImageOperation.cpp
+++ b/source/blender/compositor/operations/COM_ImageOperation.cpp
@@ -108,7 +108,7 @@ void BaseImageOperation::determineResolution(unsigned int resolution[], unsigned
 	}
 }
 
-void ImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	if (this->m_imageBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
 		zero_v4(color);
@@ -128,7 +128,7 @@ void ImageOperation::executePixel(float *color, float x, float y, PixelSampler s
 	}
 }
 
-void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float tempcolor[4];
 
@@ -152,7 +152,7 @@ void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSamp
 	}
 }
 
-void ImageDepthOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ImageDepthOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	if (this->m_depthBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
 		color[0] = 0.0f;
diff --git a/source/blender/compositor/operations/COM_ImageOperation.h b/source/blender/compositor/operations/COM_ImageOperation.h
index c87b06b9c4d..847096c7d43 100644
--- a/source/blender/compositor/operations/COM_ImageOperation.h
+++ b/source/blender/compositor/operations/COM_ImageOperation.h
@@ -73,7 +73,7 @@ public:
 	 * Constructor
 	 */
 	ImageOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 class ImageAlphaOperation : public BaseImageOperation {
 public:
@@ -81,7 +81,7 @@ public:
 	 * Constructor
 	 */
 	ImageAlphaOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 class ImageDepthOperation : public BaseImageOperation {
 public:
@@ -89,6 +89,6 @@ public:
 	 * Constructor
 	 */
 	ImageDepthOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_InvertOperation.cpp b/source/blender/compositor/operations/COM_InvertOperation.cpp
index 9e9c2522d66..0802d2d2523 100644
--- a/source/blender/compositor/operations/COM_InvertOperation.cpp
+++ b/source/blender/compositor/operations/COM_InvertOperation.cpp
@@ -39,12 +39,12 @@ void InvertOperation::initExecution()
 	this->m_inputColorProgram = this->getInputSocketReader(1);
 }
 
-void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sampler)
 {
 	float inputValue[4];
 	float inputColor[4];
-	this->m_inputValueProgram->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputColorProgram->read(inputColor, x, y, sampler, inputBuffers);
+	this->m_inputValueProgram->read(inputValue, x, y, sampler);
+	this->m_inputColorProgram->read(inputColor, x, y, sampler);
 	
 	const float value = inputValue[0];
 	const float invertedValue = 1.0f - value;
diff --git a/source/blender/compositor/operations/COM_InvertOperation.h b/source/blender/compositor/operations/COM_InvertOperation.h
index f00a3fb739d..46a5d80b04a 100644
--- a/source/blender/compositor/operations/COM_InvertOperation.h
+++ b/source/blender/compositor/operations/COM_InvertOperation.h
@@ -42,7 +42,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp b/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
index 3285bd32039..00ea5877d63 100644
--- a/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
@@ -39,14 +39,14 @@ KeyingBlurOperation::KeyingBlurOperation() : NodeOperation()
 	this->setComplex(true);
 }
 
-void *KeyingBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *KeyingBlurOperation::initializeTileData(rcti *rect)
 {
-	void *buffer = getInputOperation(0)->initializeTileData(rect, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(rect);
 
 	return buffer;
 }
 
-void KeyingBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void KeyingBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
 	float *buffer = inputBuffer->getBuffer();
diff --git a/source/blender/compositor/operations/COM_KeyingBlurOperation.h b/source/blender/compositor/operations/COM_KeyingBlurOperation.h
index 6e08712bf39..84406c33c28 100644
--- a/source/blender/compositor/operations/COM_KeyingBlurOperation.h
+++ b/source/blender/compositor/operations/COM_KeyingBlurOperation.h
@@ -45,9 +45,9 @@ public:
 	void setSize(int value) {this->m_size = value;}
 	void setAxis(int value) {this->m_axis = value;}
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
-	void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.cpp b/source/blender/compositor/operations/COM_KeyingClipOperation.cpp
index 8f7d7fbf625..d8afaceb37b 100644
--- a/source/blender/compositor/operations/COM_KeyingClipOperation.cpp
+++ b/source/blender/compositor/operations/COM_KeyingClipOperation.cpp
@@ -44,14 +44,14 @@ KeyingClipOperation::KeyingClipOperation() : NodeOperation()
 	this->setComplex(true);
 }
 
-void *KeyingClipOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *KeyingClipOperation::initializeTileData(rcti *rect)
 {
-	void *buffer = getInputOperation(0)->initializeTileData(rect, memoryBuffers);
+	void *buffer = getInputOperation(0)->initializeTileData(rect);
 
 	return buffer;
 }
 
-void KeyingClipOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void KeyingClipOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const int delta = this->m_kernelRadius;
 	const float tolerance = this->m_kernelTolerance;
diff --git a/source/blender/compositor/operations/COM_KeyingClipOperation.h b/source/blender/compositor/operations/COM_KeyingClipOperation.h
index 1a8e71a306b..eacbccc0818 100644
--- a/source/blender/compositor/operations/COM_KeyingClipOperation.h
+++ b/source/blender/compositor/operations/COM_KeyingClipOperation.h
@@ -49,9 +49,9 @@ public:
 
 	void setIsEdgeMatte(bool value) {this->m_isEdgeMatte = value;}
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
-	void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp b/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp
index 9798ddcee94..2f3fa2bd72a 100644
--- a/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp
+++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.cpp
@@ -65,13 +65,13 @@ void KeyingDespillOperation::deinitExecution()
 	this->m_screenReader = NULL;
 }
 
-void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float pixelColor[4];
 	float screenColor[4];
 
-	this->m_pixelReader->read(pixelColor, x, y, sampler, inputBuffers);
-	this->m_screenReader->read(screenColor, x, y, sampler, inputBuffers);
+	this->m_pixelReader->read(pixelColor, x, y, sampler);
+	this->m_screenReader->read(screenColor, x, y, sampler);
 
 	int screen_primary_channel = get_pixel_primary_channel(screenColor);
 	int other_1 = (screen_primary_channel + 1) % 3;
diff --git a/source/blender/compositor/operations/COM_KeyingDespillOperation.h b/source/blender/compositor/operations/COM_KeyingDespillOperation.h
index 3485bf1952f..c6e489057c3 100644
--- a/source/blender/compositor/operations/COM_KeyingDespillOperation.h
+++ b/source/blender/compositor/operations/COM_KeyingDespillOperation.h
@@ -45,7 +45,7 @@ public:
 	void setDespillFactor(float value) {this->m_despillFactor = value;}
 	void setColorBalance(float value) {this->m_colorBalance = value;}
 
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_KeyingOperation.cpp b/source/blender/compositor/operations/COM_KeyingOperation.cpp
index 48d1967b5b3..5912c206a84 100644
--- a/source/blender/compositor/operations/COM_KeyingOperation.cpp
+++ b/source/blender/compositor/operations/COM_KeyingOperation.cpp
@@ -85,17 +85,17 @@ void KeyingOperation::deinitExecution()
 	this->m_coreReader = NULL;
 }
 
-void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float pixelColor[4];
 	float screenColor[4];
 	float garbageValue[4];
 	float coreValue[4];
 
-	this->m_pixelReader->read(pixelColor, x, y, sampler, inputBuffers);
-	this->m_screenReader->read(screenColor, x, y, sampler, inputBuffers);
-	this->m_garbageReader->read(garbageValue, x, y, sampler, inputBuffers);
-	this->m_coreReader->read(coreValue, x, y, sampler, inputBuffers);
+	this->m_pixelReader->read(pixelColor, x, y, sampler);
+	this->m_screenReader->read(screenColor, x, y, sampler);
+	this->m_garbageReader->read(garbageValue, x, y, sampler);
+	this->m_coreReader->read(coreValue, x, y, sampler);
 
 	int primary_channel = get_pixel_primary_channel(screenColor);
 
diff --git a/source/blender/compositor/operations/COM_KeyingOperation.h b/source/blender/compositor/operations/COM_KeyingOperation.h
index 736db54850a..413aaf6a81e 100644
--- a/source/blender/compositor/operations/COM_KeyingOperation.h
+++ b/source/blender/compositor/operations/COM_KeyingOperation.h
@@ -51,7 +51,7 @@ public:
 
 	void setScreenBalance(float value) {this->m_screenBalance = value;}
 
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp b/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
index 134fd8bc7fe..fd3a8d64357 100644
--- a/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
+++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
@@ -217,7 +217,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri
 	return triangulation;
 }
 
-void *KeyingScreenOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *KeyingScreenOperation::initializeTileData(rcti *rect)
 {
 	TileData *tile_data;
 	TriangulationData *triangulation;
@@ -272,7 +272,7 @@ void *KeyingScreenOperation::initializeTileData(rcti *rect, MemoryBuffer **memor
 	return tile_data;
 }
 
-void KeyingScreenOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
+void KeyingScreenOperation::deinitializeTileData(rcti *rect, void *data)
 {
 	TileData *tile_data = (TileData *) data;
 
@@ -301,7 +301,7 @@ void KeyingScreenOperation::determineResolution(unsigned int resolution[], unsig
 	}
 }
 
-void KeyingScreenOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void KeyingScreenOperation::executePixel(float *color, int x, int y, void *data)
 {
 	color[0] = 0.0f;
 	color[1] = 0.0f;
diff --git a/source/blender/compositor/operations/COM_KeyingScreenOperation.h b/source/blender/compositor/operations/COM_KeyingScreenOperation.h
index 95815cd3930..f6982ef09f3 100644
--- a/source/blender/compositor/operations/COM_KeyingScreenOperation.h
+++ b/source/blender/compositor/operations/COM_KeyingScreenOperation.h
@@ -73,14 +73,14 @@ public:
 	void initExecution();
 	void deinitExecution();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-	void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+	void *initializeTileData(rcti *rect);
+	void deinitializeTileData(rcti *rect, void *data);
 
 	void setMovieClip(MovieClip *clip) {this->m_movieClip = clip;}
 	void setTrackingObject(const char *object) {strncpy(this->m_trackingObject, object, sizeof(this->m_trackingObject));}
 	void setFramenumber(int framenumber) {this->m_framenumber = framenumber;}
 
-	void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
index 233f903c3e3..7f637c127c1 100644
--- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
@@ -40,7 +40,7 @@ void LuminanceMatteOperation::deinitExecution()
 	this->m_inputImageProgram = NULL;
 }
 
-void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inColor[4];
 
@@ -49,7 +49,7 @@ void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y,
 
 	float alpha;
 
-	this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers);
+	this->m_inputImageProgram->read(inColor, x, y, sampler);
 	
 	/* one line thread-friend algorithm:
 	 * outputValue[0] = max(inputValue[3], min(high, max(low, ((inColor[0]-low)/(high-low))))
diff --git a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h
index 041fd0d7ee9..c1ab628f787 100644
--- a/source/blender/compositor/operations/COM_LuminanceMatteOperation.h
+++ b/source/blender/compositor/operations/COM_LuminanceMatteOperation.h
@@ -41,7 +41,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_MapUVOperation.cpp b/source/blender/compositor/operations/COM_MapUVOperation.cpp
index dec2d0849c9..a5f503a669b 100644
--- a/source/blender/compositor/operations/COM_MapUVOperation.cpp
+++ b/source/blender/compositor/operations/COM_MapUVOperation.cpp
@@ -40,7 +40,7 @@ void MapUVOperation::initExecution()
 	this->m_inputUVProgram = this->getInputSocketReader(1);
 }
 
-void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float inputUV[4];
 	float uv_a[4], uv_b[4];
@@ -50,30 +50,30 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
 	float uv_l, uv_r;
 	float uv_u, uv_d;
 
-	this->m_inputUVProgram->read(inputUV, x, y, sampler, inputBuffers);
+	this->m_inputUVProgram->read(inputUV, x, y, sampler);
 	if (inputUV[2] == 0.f) {
 		zero_v4(color);
 		return;
 	}
 	/* adaptive sampling, red (U) channel */
-	this->m_inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST, inputBuffers);
-	this->m_inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST, inputBuffers);
+	this->m_inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST);
+	this->m_inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST);
 	uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f;
 	uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f;
 
 	dx = 0.5f * (uv_l + uv_r);
 
 	/* adaptive sampling, green (V) channel */
-	this->m_inputUVProgram->read(uv_a, x, y - 1, COM_PS_NEAREST, inputBuffers);
-	this->m_inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST, inputBuffers);
+	this->m_inputUVProgram->read(uv_a, x, y - 1, COM_PS_NEAREST);
+	this->m_inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST);
 	uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f;
 	uv_d = uv_b[2] != 0.f ? fabsf(inputUV[1] - uv_b[1]) : 0.f;
 
 	dy = 0.5f * (uv_u + uv_d);
 
 	/* more adaptive sampling, red and green (UV) channels */
-	this->m_inputUVProgram->read(uv_a, x - 1, y - 1, COM_PS_NEAREST, inputBuffers);
-	this->m_inputUVProgram->read(uv_b, x - 1, y + 1, COM_PS_NEAREST, inputBuffers);
+	this->m_inputUVProgram->read(uv_a, x - 1, y - 1, COM_PS_NEAREST);
+	this->m_inputUVProgram->read(uv_b, x - 1, y + 1, COM_PS_NEAREST);
 	uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f;
 	uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f;
 	uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f;
@@ -82,8 +82,8 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
 	dx += 0.25f * (uv_l + uv_r);
 	dy += 0.25f * (uv_u + uv_d);
 
-	this->m_inputUVProgram->read(uv_a, x + 1, y - 1, COM_PS_NEAREST, inputBuffers);
-	this->m_inputUVProgram->read(uv_b, x + 1, y + 1, COM_PS_NEAREST, inputBuffers);
+	this->m_inputUVProgram->read(uv_a, x + 1, y - 1, COM_PS_NEAREST);
+	this->m_inputUVProgram->read(uv_b, x + 1, y + 1, COM_PS_NEAREST);
 	uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f;
 	uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f;
 	uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f;
@@ -107,7 +107,7 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
 	u = inputUV[0] * this->m_inputColorProgram->getWidth();
 	v = inputUV[1] * this->m_inputColorProgram->getHeight();
 
-	this->m_inputColorProgram->read(color, u, v, dx, dy, inputBuffers);
+	this->m_inputColorProgram->read(color, u, v, dx, dy);
 
 	/* "premul" */
 	if (alpha < 1.0f) {
diff --git a/source/blender/compositor/operations/COM_MapUVOperation.h b/source/blender/compositor/operations/COM_MapUVOperation.h
index c14640da61c..ae042f60789 100644
--- a/source/blender/compositor/operations/COM_MapUVOperation.h
+++ b/source/blender/compositor/operations/COM_MapUVOperation.h
@@ -45,7 +45,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_MapValueOperation.cpp b/source/blender/compositor/operations/COM_MapValueOperation.cpp
index 17d82e85723..96e586ccef8 100644
--- a/source/blender/compositor/operations/COM_MapValueOperation.cpp
+++ b/source/blender/compositor/operations/COM_MapValueOperation.cpp
@@ -34,10 +34,10 @@ void MapValueOperation::initExecution()
 	this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void MapValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MapValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float src[4];
-	this->m_inputOperation->read(src, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(src, x, y, sampler);
 	TexMapping *texmap = this->m_settings;
 	float value = (src[0] + texmap->loc[0]) * texmap->size[0];
 	if (texmap->flag & TEXMAP_CLIP_MIN)
diff --git a/source/blender/compositor/operations/COM_MapValueOperation.h b/source/blender/compositor/operations/COM_MapValueOperation.h
index fb50d0fbe4d..a2664c32a4e 100644
--- a/source/blender/compositor/operations/COM_MapValueOperation.h
+++ b/source/blender/compositor/operations/COM_MapValueOperation.h
@@ -45,7 +45,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_MaskOperation.cpp b/source/blender/compositor/operations/COM_MaskOperation.cpp
index 682ccf712ad..5674582a21a 100644
--- a/source/blender/compositor/operations/COM_MaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_MaskOperation.cpp
@@ -70,7 +70,7 @@ void MaskOperation::deinitExecution()
 	}
 }
 
-void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *MaskOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_rasterizedMask)
 		return this->m_rasterizedMask;
@@ -117,7 +117,7 @@ void MaskOperation::determineResolution(unsigned int resolution[], unsigned int
 	}
 }
 
-void MaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void MaskOperation::executePixel(float *color, int x, int y, void *data)
 {
 	if (!data) {
 		color[0] = 0.0f;
@@ -167,7 +167,7 @@ void MaskOperation::deinitExecution()
 	deinitMutex();
 }
 
-void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *MaskOperation::initializeTileData(rcti *rect)
 {
 	/* pass */
 	return NULL;
@@ -191,7 +191,7 @@ void MaskOperation::determineResolution(unsigned int resolution[], unsigned int
 	}
 }
 
-void MaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void MaskOperation::executePixel(float *color, int x, int y, void *data)
 {
 	const float xy[2] = {x / (float)this->m_maskWidth, y / (float)this->m_maskHeight};
 	color[0] = BLI_maskrasterize_handle_sample(this->m_rasterMaskHandle, xy);
diff --git a/source/blender/compositor/operations/COM_MaskOperation.h b/source/blender/compositor/operations/COM_MaskOperation.h
index 8fb98481ec7..d761ee58cb9 100644
--- a/source/blender/compositor/operations/COM_MaskOperation.h
+++ b/source/blender/compositor/operations/COM_MaskOperation.h
@@ -72,7 +72,7 @@ public:
 	void initExecution();
 	void deinitExecution();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
 	void setMask(Mask *mask) { this->m_mask = mask; }
 	void setMaskWidth(int width) { this->m_maskWidth = width; }
@@ -81,7 +81,7 @@ public:
 	void setSmooth(bool smooth) { this->m_do_smooth = smooth; }
 	void setFeather(bool feather) { this->m_do_feather = feather; }
 
-	void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.cpp b/source/blender/compositor/operations/COM_MathBaseOperation.cpp
index 596895a963a..6c0c27c2522 100644
--- a/source/blender/compositor/operations/COM_MathBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_MathBaseOperation.cpp
@@ -71,52 +71,52 @@ void MathBaseOperation::clampIfNeeded(float *color)
 	}
 }
 
-void MathAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = inputValue1[0] + inputValue2[0];
 
 	clampIfNeeded(outputValue);
 }
 
-void MathSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = inputValue1[0] - inputValue2[0];
 
 	clampIfNeeded(outputValue);
 }
 
-void MathMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = inputValue1[0] * inputValue2[0];
 
 	clampIfNeeded(outputValue);
 }
 
-void MathDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	if (inputValue2[0] == 0) /* We don't want to divide by zero. */
 		outputValue[0] = 0.0;
@@ -126,52 +126,52 @@ void MathDivideOperation::executePixel(float *outputValue, float x, float y, Pix
 	clampIfNeeded(outputValue);
 }
 
-void MathSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = sin(inputValue1[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = cos(inputValue1[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = tan(inputValue1[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathArcSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathArcSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	if (inputValue1[0] <= 1 && inputValue1[0] >= -1)
 		outputValue[0] = asin(inputValue1[0]);
@@ -181,13 +181,13 @@ void MathArcSineOperation::executePixel(float *outputValue, float x, float y, Pi
 	clampIfNeeded(outputValue);
 }
 
-void MathArcCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathArcCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	if (inputValue1[0] <= 1 && inputValue1[0] >= -1)
 		outputValue[0] = acos(inputValue1[0]);
@@ -197,26 +197,26 @@ void MathArcCosineOperation::executePixel(float *outputValue, float x, float y,
 	clampIfNeeded(outputValue);
 }
 
-void MathArcTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathArcTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = atan(inputValue1[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathPowerOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathPowerOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	if (inputValue1[0] >= 0) {
 		outputValue[0] = pow(inputValue1[0], inputValue2[0]);
@@ -235,13 +235,13 @@ void MathPowerOperation::executePixel(float *outputValue, float x, float y, Pixe
 	clampIfNeeded(outputValue);
 }
 
-void MathLogarithmOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathLogarithmOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	if (inputValue1[0] > 0  && inputValue2[0] > 0)
 		outputValue[0] = log(inputValue1[0]) / log(inputValue2[0]);
@@ -251,65 +251,65 @@ void MathLogarithmOperation::executePixel(float *outputValue, float x, float y,
 	clampIfNeeded(outputValue);
 }
 
-void MathMinimumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathMinimumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = min(inputValue1[0], inputValue2[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathMaximumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathMaximumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = max(inputValue1[0], inputValue2[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathRoundOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathRoundOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = round(inputValue1[0]);
 
 	clampIfNeeded(outputValue);
 }
 
-void MathLessThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathLessThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = inputValue1[0] < inputValue2[0] ? 1.0f : 0.0f;
 
 	clampIfNeeded(outputValue);
 }
 
-void MathGreaterThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathGreaterThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputValue1[4];
 	float inputValue2[4];
 	
-	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+	this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+	this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
 	
 	outputValue[0] = inputValue1[0] > inputValue2[0] ? 1.0f : 0.0f;
 
diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.h b/source/blender/compositor/operations/COM_MathBaseOperation.h
index e53176aea49..8fc6c762b16 100644
--- a/source/blender/compositor/operations/COM_MathBaseOperation.h
+++ b/source/blender/compositor/operations/COM_MathBaseOperation.h
@@ -50,7 +50,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]) = 0;
+	void executePixel(float *color, float x, float y, PixelSampler sampler) = 0;
 	
 	/**
 	 * Initialize the execution
@@ -73,88 +73,88 @@ public:
 class MathAddOperation : public MathBaseOperation {
 public:
 	MathAddOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathSubtractOperation : public MathBaseOperation {
 public:
 	MathSubtractOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathMultiplyOperation : public MathBaseOperation {
 public:
 	MathMultiplyOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathDivideOperation : public MathBaseOperation {
 public:
 	MathDivideOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathSineOperation : public MathBaseOperation {
 public:
 	MathSineOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathCosineOperation : public MathBaseOperation {
 public:
 	MathCosineOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathTangentOperation : public MathBaseOperation {
 public:
 	MathTangentOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 
 class MathArcSineOperation : public MathBaseOperation {
 public:
 	MathArcSineOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathArcCosineOperation : public MathBaseOperation {
 public:
 	MathArcCosineOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathArcTangentOperation : public MathBaseOperation {
 public:
 	MathArcTangentOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathPowerOperation : public MathBaseOperation {
 public:
 	MathPowerOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathLogarithmOperation : public MathBaseOperation {
 public:
 	MathLogarithmOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathMinimumOperation : public MathBaseOperation {
 public:
 	MathMinimumOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathMaximumOperation : public MathBaseOperation {
 public:
 	MathMaximumOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathRoundOperation : public MathBaseOperation {
 public:
 	MathRoundOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathLessThanOperation : public MathBaseOperation {
 public:
 	MathLessThanOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathGreaterThanOperation : public MathBaseOperation {
 public:
 	MathGreaterThanOperation() : MathBaseOperation() {}
-	void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_MixAddOperation.cpp b/source/blender/compositor/operations/COM_MixAddOperation.cpp
index f8bd802928d..b49c65cc010 100644
--- a/source/blender/compositor/operations/COM_MixAddOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixAddOperation.cpp
@@ -27,15 +27,15 @@ MixAddOperation::MixAddOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float inputValue[4];
 	
-	this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
 
 
 	float value = inputValue[0];
diff --git a/source/blender/compositor/operations/COM_MixAddOperation.h b/source/blender/compositor/operations/COM_MixAddOperation.h
index c5eaf0a4d77..8fc41706073 100644
--- a/source/blender/compositor/operations/COM_MixAddOperation.h
+++ b/source/blender/compositor/operations/COM_MixAddOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixBaseOperation.cpp b/source/blender/compositor/operations/COM_MixBaseOperation.cpp
index df9297c568b..e9dd7078f83 100644
--- a/source/blender/compositor/operations/COM_MixBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixBaseOperation.cpp
@@ -41,15 +41,15 @@ void MixBaseOperation::initExecution()
 	this->m_inputColor2Operation = this->getInputSocketReader(2);
 }
 
-void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float inputValue[4];
 	
-	this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
 	
 	float value = inputValue[0];
 	if (this->useValueAlphaMultiply()) {
diff --git a/source/blender/compositor/operations/COM_MixBaseOperation.h b/source/blender/compositor/operations/COM_MixBaseOperation.h
index 1bba2818017..0a8ed4fa0e1 100644
--- a/source/blender/compositor/operations/COM_MixBaseOperation.h
+++ b/source/blender/compositor/operations/COM_MixBaseOperation.h
@@ -59,7 +59,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_MixBlendOperation.cpp b/source/blender/compositor/operations/COM_MixBlendOperation.cpp
index 0c6ede01797..090343e8450 100644
--- a/source/blender/compositor/operations/COM_MixBlendOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixBlendOperation.cpp
@@ -27,16 +27,16 @@ MixBlendOperation::MixBlendOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixBlendOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixBlendOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float inputValue[4];
 	float value;
 	
-	this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
 	value = inputValue[0];
 	
 	if (this->useValueAlphaMultiply()) {
diff --git a/source/blender/compositor/operations/COM_MixBlendOperation.h b/source/blender/compositor/operations/COM_MixBlendOperation.h
index 16ad635bebd..6073ca1fc52 100644
--- a/source/blender/compositor/operations/COM_MixBlendOperation.h
+++ b/source/blender/compositor/operations/COM_MixBlendOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixBurnOperation.cpp b/source/blender/compositor/operations/COM_MixBurnOperation.cpp
index 0d736583c58..fbb3cb7b27b 100644
--- a/source/blender/compositor/operations/COM_MixBurnOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixBurnOperation.cpp
@@ -27,16 +27,16 @@ MixBurnOperation::MixBurnOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	float tmp;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixBurnOperation.h b/source/blender/compositor/operations/COM_MixBurnOperation.h
index 7412f651ab3..88435f05503 100644
--- a/source/blender/compositor/operations/COM_MixBurnOperation.h
+++ b/source/blender/compositor/operations/COM_MixBurnOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixColorOperation.cpp b/source/blender/compositor/operations/COM_MixColorOperation.cpp
index e7f7eb4d656..378cfbd9b6c 100644
--- a/source/blender/compositor/operations/COM_MixColorOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixColorOperation.cpp
@@ -31,15 +31,15 @@ MixColorOperation::MixColorOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixColorOperation.h b/source/blender/compositor/operations/COM_MixColorOperation.h
index 028ff517132..fb91a426f40 100644
--- a/source/blender/compositor/operations/COM_MixColorOperation.h
+++ b/source/blender/compositor/operations/COM_MixColorOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixDarkenOperation.cpp b/source/blender/compositor/operations/COM_MixDarkenOperation.cpp
index f229a89fdab..68f9c023733 100644
--- a/source/blender/compositor/operations/COM_MixDarkenOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixDarkenOperation.cpp
@@ -27,15 +27,15 @@ MixDarkenOperation::MixDarkenOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixDarkenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDarkenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixDarkenOperation.h b/source/blender/compositor/operations/COM_MixDarkenOperation.h
index 337fa1a7024..8b5afaecbd5 100644
--- a/source/blender/compositor/operations/COM_MixDarkenOperation.h
+++ b/source/blender/compositor/operations/COM_MixDarkenOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp b/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
index 70d62182278..48964e8b78b 100644
--- a/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
@@ -28,15 +28,15 @@ MixDifferenceOperation::MixDifferenceOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixDifferenceOperation.h b/source/blender/compositor/operations/COM_MixDifferenceOperation.h
index 503fbb691d3..f4ad5d07586 100644
--- a/source/blender/compositor/operations/COM_MixDifferenceOperation.h
+++ b/source/blender/compositor/operations/COM_MixDifferenceOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixDivideOperation.cpp b/source/blender/compositor/operations/COM_MixDivideOperation.cpp
index 7ca47c4f507..d9d2383001b 100644
--- a/source/blender/compositor/operations/COM_MixDivideOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixDivideOperation.cpp
@@ -27,15 +27,15 @@ MixDivideOperation::MixDivideOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixDivideOperation.h b/source/blender/compositor/operations/COM_MixDivideOperation.h
index db60a39f93f..8f94fc2d510 100644
--- a/source/blender/compositor/operations/COM_MixDivideOperation.h
+++ b/source/blender/compositor/operations/COM_MixDivideOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixDodgeOperation.cpp b/source/blender/compositor/operations/COM_MixDodgeOperation.cpp
index b8ed3e252a9..34c6e4043f2 100644
--- a/source/blender/compositor/operations/COM_MixDodgeOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixDodgeOperation.cpp
@@ -27,16 +27,16 @@ MixDodgeOperation::MixDodgeOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixDodgeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDodgeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	float tmp;
 
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixDodgeOperation.h b/source/blender/compositor/operations/COM_MixDodgeOperation.h
index 32aa8593657..f99a82dca8d 100644
--- a/source/blender/compositor/operations/COM_MixDodgeOperation.h
+++ b/source/blender/compositor/operations/COM_MixDodgeOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixGlareOperation.cpp b/source/blender/compositor/operations/COM_MixGlareOperation.cpp
index f0729bec23d..4a569404ddc 100644
--- a/source/blender/compositor/operations/COM_MixGlareOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixGlareOperation.cpp
@@ -27,16 +27,16 @@ MixGlareOperation::MixGlareOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixGlareOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixGlareOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float inputValue[4];
 	float value;
 	
-	this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
 	value = inputValue[0];
 	float mf = 2.f - 2.f * fabsf(value - 0.5f);
 	
diff --git a/source/blender/compositor/operations/COM_MixGlareOperation.h b/source/blender/compositor/operations/COM_MixGlareOperation.h
index 1c715d7414b..23b9f2420a0 100644
--- a/source/blender/compositor/operations/COM_MixGlareOperation.h
+++ b/source/blender/compositor/operations/COM_MixGlareOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixHueOperation.cpp b/source/blender/compositor/operations/COM_MixHueOperation.cpp
index 5528597ab17..3745f502709 100644
--- a/source/blender/compositor/operations/COM_MixHueOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixHueOperation.cpp
@@ -31,15 +31,15 @@ MixHueOperation::MixHueOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixHueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixHueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixHueOperation.h b/source/blender/compositor/operations/COM_MixHueOperation.h
index ff1ef369440..1c8eadabbbd 100644
--- a/source/blender/compositor/operations/COM_MixHueOperation.h
+++ b/source/blender/compositor/operations/COM_MixHueOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixLightenOperation.cpp b/source/blender/compositor/operations/COM_MixLightenOperation.cpp
index d742bc27b00..868459db8bf 100644
--- a/source/blender/compositor/operations/COM_MixLightenOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixLightenOperation.cpp
@@ -27,15 +27,15 @@ MixLightenOperation::MixLightenOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixLightenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixLightenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixLightenOperation.h b/source/blender/compositor/operations/COM_MixLightenOperation.h
index dd51215b26a..d03ab317035 100644
--- a/source/blender/compositor/operations/COM_MixLightenOperation.h
+++ b/source/blender/compositor/operations/COM_MixLightenOperation.h
@@ -39,6 +39,6 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp b/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
index 006faf3f18b..2fff05fbbc9 100644
--- a/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
@@ -27,15 +27,15 @@ MixLinearLightOperation::MixLinearLightOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixLinearLightOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixLinearLightOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixLinearLightOperation.h b/source/blender/compositor/operations/COM_MixLinearLightOperation.h
index e96e2b7eaf7..7a9acbe00b0 100644
--- a/source/blender/compositor/operations/COM_MixLinearLightOperation.h
+++ b/source/blender/compositor/operations/COM_MixLinearLightOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp b/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
index a480182a785..911c0c83b90 100644
--- a/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
@@ -27,15 +27,15 @@ MixMultiplyOperation::MixMultiplyOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float inputValue[4];
 	
-	this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(inputValue, x, y, sampler);
+	this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+	this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
 	
 	float value = inputValue[0];
 	if (this->useValueAlphaMultiply()) {
diff --git a/source/blender/compositor/operations/COM_MixMultiplyOperation.h b/source/blender/compositor/operations/COM_MixMultiplyOperation.h
index 4c89a8f2957..ab7d06aecf6 100644
--- a/source/blender/compositor/operations/COM_MixMultiplyOperation.h
+++ b/source/blender/compositor/operations/COM_MixMultiplyOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixOverlayOperation.cpp b/source/blender/compositor/operations/COM_MixOverlayOperation.cpp
index 7c39f70faaa..ba7a86a80a7 100644
--- a/source/blender/compositor/operations/COM_MixOverlayOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixOverlayOperation.cpp
@@ -27,15 +27,15 @@ MixOverlayOperation::MixOverlayOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixOverlayOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixOverlayOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixOverlayOperation.h b/source/blender/compositor/operations/COM_MixOverlayOperation.h
index 7de955b9f4f..d31396f471b 100644
--- a/source/blender/compositor/operations/COM_MixOverlayOperation.h
+++ b/source/blender/compositor/operations/COM_MixOverlayOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixSaturationOperation.cpp b/source/blender/compositor/operations/COM_MixSaturationOperation.cpp
index 1ae856d2ba0..403dac57615 100644
--- a/source/blender/compositor/operations/COM_MixSaturationOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixSaturationOperation.cpp
@@ -31,15 +31,15 @@ MixSaturationOperation::MixSaturationOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixSaturationOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixSaturationOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixSaturationOperation.h b/source/blender/compositor/operations/COM_MixSaturationOperation.h
index 241009e2645..f89f03c0e18 100644
--- a/source/blender/compositor/operations/COM_MixSaturationOperation.h
+++ b/source/blender/compositor/operations/COM_MixSaturationOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixScreenOperation.cpp b/source/blender/compositor/operations/COM_MixScreenOperation.cpp
index c4ec210eb1c..781bc87ece7 100644
--- a/source/blender/compositor/operations/COM_MixScreenOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixScreenOperation.cpp
@@ -27,15 +27,15 @@ MixScreenOperation::MixScreenOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixScreenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixScreenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float valuev[4];
 
-	this->m_inputValueOperation->read(valuev, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(valuev, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
 	float value = valuev[0];
 	if (this->useValueAlphaMultiply()) {
diff --git a/source/blender/compositor/operations/COM_MixScreenOperation.h b/source/blender/compositor/operations/COM_MixScreenOperation.h
index 4d0c1fded3d..843adc870f8 100644
--- a/source/blender/compositor/operations/COM_MixScreenOperation.h
+++ b/source/blender/compositor/operations/COM_MixScreenOperation.h
@@ -39,6 +39,6 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp b/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
index 9de56fde87d..b1374aa7f32 100644
--- a/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
@@ -27,15 +27,15 @@ MixSoftLightOperation::MixSoftLightOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixSoftLightOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) \
+void MixSoftLightOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler) \
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixSoftLightOperation.h b/source/blender/compositor/operations/COM_MixSoftLightOperation.h
index bcb718027b2..570cf2cb6ef 100644
--- a/source/blender/compositor/operations/COM_MixSoftLightOperation.h
+++ b/source/blender/compositor/operations/COM_MixSoftLightOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixSubtractOperation.cpp b/source/blender/compositor/operations/COM_MixSubtractOperation.cpp
index 4861346c9da..f7b558e5c7a 100644
--- a/source/blender/compositor/operations/COM_MixSubtractOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixSubtractOperation.cpp
@@ -27,15 +27,15 @@ MixSubtractOperation::MixSubtractOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 	
-	this->m_inputValueOperation->read(&value,   x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0],   x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0],   x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value,   x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0],   x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0],   x, y, sampler);
 	
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixSubtractOperation.h b/source/blender/compositor/operations/COM_MixSubtractOperation.h
index 3c8112b0e36..a9198cf3400 100644
--- a/source/blender/compositor/operations/COM_MixSubtractOperation.h
+++ b/source/blender/compositor/operations/COM_MixSubtractOperation.h
@@ -39,7 +39,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MixValueOperation.cpp b/source/blender/compositor/operations/COM_MixValueOperation.cpp
index 511bbdf85f4..8f8d3305ee9 100644
--- a/source/blender/compositor/operations/COM_MixValueOperation.cpp
+++ b/source/blender/compositor/operations/COM_MixValueOperation.cpp
@@ -31,15 +31,15 @@ MixValueOperation::MixValueOperation() : MixBaseOperation()
 	/* pass */
 }
 
-void MixValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float inputColor1[4];
 	float inputColor2[4];
 	float value;
 
-	this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+	this->m_inputValueOperation->read(&value, x, y, sampler);
+	this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+	this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
 	if (this->useValueAlphaMultiply()) {
 		value *= inputColor2[3];
diff --git a/source/blender/compositor/operations/COM_MixValueOperation.h b/source/blender/compositor/operations/COM_MixValueOperation.h
index c0f3ce10f29..06316afcd73 100644
--- a/source/blender/compositor/operations/COM_MixValueOperation.h
+++ b/source/blender/compositor/operations/COM_MixValueOperation.h
@@ -39,6 +39,6 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
index 1af206920c5..14d7fa7e649 100644
--- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
+++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
@@ -33,7 +33,7 @@ MovieClipAttributeOperation::MovieClipAttributeOperation() : NodeOperation()
 	this->m_attribute = MCA_X;
 }
 
-void MovieClipAttributeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MovieClipAttributeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	if (!this->m_valueSet) {
 		float loc[2], scale, angle;
diff --git a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h
index c6422fbbfc2..28028ab6fd4 100644
--- a/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h
+++ b/source/blender/compositor/operations/COM_MovieClipAttributeOperation.h
@@ -51,7 +51,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 
 	void setMovieClip(MovieClip *clip) { this->m_clip = clip; }
diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.cpp b/source/blender/compositor/operations/COM_MovieClipOperation.cpp
index a5cc7196f62..8b88f5c7d14 100644
--- a/source/blender/compositor/operations/COM_MovieClipOperation.cpp
+++ b/source/blender/compositor/operations/COM_MovieClipOperation.cpp
@@ -92,7 +92,7 @@ void MovieClipOperation::determineResolution(unsigned int resolution[], unsigned
 	}
 }
 
-void MovieClipOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MovieClipOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	if (this->m_movieClipBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
 		zero_v4(color);
diff --git a/source/blender/compositor/operations/COM_MovieClipOperation.h b/source/blender/compositor/operations/COM_MovieClipOperation.h
index 50d79213428..f3e95818bd7 100644
--- a/source/blender/compositor/operations/COM_MovieClipOperation.h
+++ b/source/blender/compositor/operations/COM_MovieClipOperation.h
@@ -60,7 +60,7 @@ public:
 	void setCacheFrame(bool value) { this->m_cacheFrame = value; }
 
 	void setFramenumber(int framenumber) { this->m_framenumber = framenumber; }
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp b/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp
index 6b423cadcc6..964d4352bc0 100644
--- a/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp
+++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.cpp
@@ -78,16 +78,16 @@ void MovieDistortionOperation::deinitExecution()
 }
 
 
-void MovieDistortionOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MovieDistortionOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	
 	if (this->m_cache != NULL) {
 		float u, v;
 		this->m_cache->getUV(&this->m_movieClip->tracking, x, y, &u, &v);
-		this->m_inputOperation->read(color, u, v, sampler, inputBuffers);
+		this->m_inputOperation->read(color, u, v, sampler);
 	} 
 	else {
-		this->m_inputOperation->read(color, x, y, sampler, inputBuffers);
+		this->m_inputOperation->read(color, x, y, sampler);
 	}
 }
 
diff --git a/source/blender/compositor/operations/COM_MovieDistortionOperation.h b/source/blender/compositor/operations/COM_MovieDistortionOperation.h
index ab81ae44597..8cd9e98da2d 100644
--- a/source/blender/compositor/operations/COM_MovieDistortionOperation.h
+++ b/source/blender/compositor/operations/COM_MovieDistortionOperation.h
@@ -130,7 +130,7 @@ protected:
 public:
 	MovieDistortionOperation(bool distortion);
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp b/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp
index 363c0379770..27214acd0d4 100644
--- a/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp
+++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.cpp
@@ -43,7 +43,7 @@ ImBuf *MultilayerBaseOperation::getImBuf()
 	return NULL;
 }
 
-void MultilayerColorOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MultilayerColorOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	int yi = y;
 	int xi = x;
@@ -74,7 +74,7 @@ void MultilayerColorOperation::executePixel(float *color, float x, float y, Pixe
 	}
 }
 
-void MultilayerValueOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MultilayerValueOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	int yi = y;
 	int xi = x;
@@ -87,7 +87,7 @@ void MultilayerValueOperation::executePixel(float *color, float x, float y, Pixe
 	}
 }
 
-void MultilayerVectorOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MultilayerVectorOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	int yi = y;
 	int xi = x;
diff --git a/source/blender/compositor/operations/COM_MultilayerImageOperation.h b/source/blender/compositor/operations/COM_MultilayerImageOperation.h
index f946c44dd35..82bd8c455df 100644
--- a/source/blender/compositor/operations/COM_MultilayerImageOperation.h
+++ b/source/blender/compositor/operations/COM_MultilayerImageOperation.h
@@ -46,7 +46,7 @@ public:
 	MultilayerColorOperation(int pass) : MultilayerBaseOperation(pass) {
 		this->addOutputSocket(COM_DT_COLOR);
 	}
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 class MultilayerValueOperation : public MultilayerBaseOperation {
@@ -54,7 +54,7 @@ public:
 	MultilayerValueOperation(int pass) : MultilayerBaseOperation(pass) {
 		this->addOutputSocket(COM_DT_VALUE);
 	}
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 class MultilayerVectorOperation : public MultilayerBaseOperation {
@@ -62,7 +62,7 @@ public:
 	MultilayerVectorOperation(int pass) : MultilayerBaseOperation(pass) {
 		this->addOutputSocket(COM_DT_VECTOR);
 	}
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.cpp b/source/blender/compositor/operations/COM_NormalizeOperation.cpp
index 8a83ef7f3ae..02ea7f2b257 100644
--- a/source/blender/compositor/operations/COM_NormalizeOperation.cpp
+++ b/source/blender/compositor/operations/COM_NormalizeOperation.cpp
@@ -35,13 +35,13 @@ void NormalizeOperation::initExecution()
 	NodeOperation::initMutex();
 }
 
-void NormalizeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void NormalizeOperation::executePixel(float *color, int x, int y, void *data)
 {
 	/* using generic two floats struct to store x: min  y: mult */
 	NodeTwoFloats *minmult = (NodeTwoFloats *)data;
 
 	float output[4];
-	this->m_imageReader->read(output, x, y, inputBuffers, NULL);
+	this->m_imageReader->read(output, x, y, NULL);
 
 	color[0] = (output[0] - minmult->x) * minmult->y;
 }
@@ -75,11 +75,11 @@ bool NormalizeOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe
 /* The code below assumes all data is inside range +- this, and that input buffer is single channel */
 #define BLENDER_ZMAX 10000.0f
 
-void *NormalizeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *NormalizeOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (this->m_cachedInstance == NULL) {
-		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect);
 		/* using generic two floats struct to store x: min  y: mult */
 		NodeTwoFloats *minmult = new NodeTwoFloats();
 
@@ -113,7 +113,7 @@ void *NormalizeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBu
 	return this->m_cachedInstance;
 }
 
-void NormalizeOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
+void NormalizeOperation::deinitializeTileData(rcti *rect, void *data)
 {
 	/* pass */
 }
diff --git a/source/blender/compositor/operations/COM_NormalizeOperation.h b/source/blender/compositor/operations/COM_NormalizeOperation.h
index 1f4a403434e..f36d69a3018 100644
--- a/source/blender/compositor/operations/COM_NormalizeOperation.h
+++ b/source/blender/compositor/operations/COM_NormalizeOperation.h
@@ -47,15 +47,15 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-	void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+	void *initializeTileData(rcti *rect);
+	void deinitializeTileData(rcti *rect, void *data);
 
 	/**
 	 * Deinitialize the execution
diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.cpp b/source/blender/compositor/operations/COM_OutputFileOperation.cpp
index 079c6ff33ec..83dae7475fb 100644
--- a/source/blender/compositor/operations/COM_OutputFileOperation.cpp
+++ b/source/blender/compositor/operations/COM_OutputFileOperation.cpp
@@ -77,7 +77,7 @@ static void write_buffer_rect(rcti *rect, const bNodeTree *tree,
 
 	for (y = y1; y < y2 && (!breaked); y++) {
 		for (x = x1; x < x2 && (!breaked); x++) {
-			reader->read(color, x, y, COM_PS_NEAREST, NULL);
+			reader->read(color, x, y, COM_PS_NEAREST);
 			
 			for (i = 0; i < size; ++i)
 				buffer[offset + i] = color[i];
diff --git a/source/blender/compositor/operations/COM_PreviewOperation.cpp b/source/blender/compositor/operations/COM_PreviewOperation.cpp
index 80cb6f6801c..8008c95c734 100644
--- a/source/blender/compositor/operations/COM_PreviewOperation.cpp
+++ b/source/blender/compositor/operations/COM_PreviewOperation.cpp
@@ -93,7 +93,7 @@ void PreviewOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 			color[1] = 0.0f;
 			color[2] = 0.0f;
 			color[3] = 1.0f;
-			this->m_input->read(color, rx, ry, COM_PS_NEAREST, NULL);
+			this->m_input->read(color, rx, ry, COM_PS_NEAREST);
 			linearrgb_to_srgb_v4(color, color);
 			F4TOCHAR4(color, this->m_outputBuffer + offset);
 			offset += 4;
diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
index 12674153bc8..daf517876e5 100644
--- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
+++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
@@ -40,14 +40,14 @@ void ProjectorLensDistortionOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void *ProjectorLensDistortionOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *ProjectorLensDistortionOperation::initializeTileData(rcti *rect)
 {
-	updateDispersion(memoryBuffers);
-	void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+	updateDispersion();
+	void *buffer = this->m_inputProgram->initializeTileData(NULL);
 	return buffer;
 }
 
-void ProjectorLensDistortionOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ProjectorLensDistortionOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float inputValue[4];
 	const float height = this->getHeight();
@@ -87,13 +87,13 @@ bool ProjectorLensDistortionOperation::determineDependingAreaOfInterest(rcti *in
 	return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output);
 }
 
-void ProjectorLensDistortionOperation::updateDispersion(MemoryBuffer **inputBuffers) 
+void ProjectorLensDistortionOperation::updateDispersion() 
 {
 	if (this->m_dispersionAvailable) return;
 	this->lockMutex();
 	if (!this->m_dispersionAvailable) {
 		float result[4];
-		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, inputBuffers);
+		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST);
 		this->m_dispersion = result[0];
 		this->m_kr = 0.25f * MAX2(MIN2(this->m_dispersion, 1.f), 0.f);
 		this->m_kr2 = this->m_kr * 20;
diff --git a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h
index c658d66429a..ac64b35ed32 100644
--- a/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h
+++ b/source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h
@@ -44,14 +44,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * Deinitialize the execution
 	 */
@@ -61,7 +61,7 @@ public:
 	
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
-	void updateDispersion(MemoryBuffer **inputBuffers);
+	void updateDispersion();
 
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.cpp b/source/blender/compositor/operations/COM_ReadBufferOperation.cpp
index c1aa51f5017..2473ad8303e 100644
--- a/source/blender/compositor/operations/COM_ReadBufferOperation.cpp
+++ b/source/blender/compositor/operations/COM_ReadBufferOperation.cpp
@@ -31,7 +31,7 @@ ReadBufferOperation::ReadBufferOperation() : NodeOperation()
 	this->m_buffer = NULL;
 }
 
-void *ReadBufferOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *ReadBufferOperation::initializeTileData(rcti *rect)
 {
 	return m_buffer;
 }
@@ -49,7 +49,7 @@ void ReadBufferOperation::determineResolution(unsigned int resolution[], unsigne
 		}
 	}
 }
-void ReadBufferOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ReadBufferOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	if (sampler == COM_PS_NEAREST) {
 		m_buffer->read(color, x, y);
@@ -59,7 +59,7 @@ void ReadBufferOperation::executePixel(float *color, float x, float y, PixelSamp
 	}
 }
 
-void ReadBufferOperation::executePixel(float *color, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[])
+void ReadBufferOperation::executePixel(float *color, float x, float y, float dx, float dy)
 {
 	m_buffer->readEWA(color, x, y, dx, dy);
 }
diff --git a/source/blender/compositor/operations/COM_ReadBufferOperation.h b/source/blender/compositor/operations/COM_ReadBufferOperation.h
index 32f2a631552..f52b732b076 100644
--- a/source/blender/compositor/operations/COM_ReadBufferOperation.h
+++ b/source/blender/compositor/operations/COM_ReadBufferOperation.h
@@ -38,9 +38,9 @@ public:
 	MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; }
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
-	void executePixel(float *color, float x, float y, float dx, float dy, MemoryBuffer * inputBuffers[]);
+	void *initializeTileData(rcti *rect);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
+	void executePixel(float *color, float x, float y, float dx, float dy);
 	const bool isReadBufferOperation() const { return true; }
 	void setOffset(unsigned int offset) { this->m_offset = offset; }
 	unsigned int getOffset() { return this->m_offset; }
diff --git a/source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp b/source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp
index 35f787cb59f..908c3d11b06 100644
--- a/source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp
+++ b/source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp
@@ -27,7 +27,7 @@ RenderLayersAlphaProg::RenderLayersAlphaProg() : RenderLayersBaseProg(SCE_PASS_C
 	this->addOutputSocket(COM_DT_VALUE);
 }
 
-void RenderLayersAlphaProg::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void RenderLayersAlphaProg::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
 	int ix = x;
 	int iy = y;
diff --git a/source/blender/compositor/operations/COM_RenderLayersAlphaProg.h b/source/blender/compositor/operations/COM_RenderLayersAlphaProg.h
index 846e337c572..1733f3bd3ba 100644
--- a/source/blender/compositor/operations/COM_RenderLayersAlphaProg.h
+++ b/source/blender/compositor/operations/COM_RenderLayersAlphaProg.h
@@ -28,7 +28,7 @@
 class RenderLayersAlphaProg : public RenderLayersBaseProg {
 public:
 	RenderLayersAlphaProg();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 
diff --git a/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp b/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
index e4543c06d9b..a036e8e7231 100644
--- a/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
+++ b/source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
@@ -69,7 +69,7 @@ void RenderLayersBaseProg::initExecution()
 	}
 }
 
-void RenderLayersBaseProg::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void RenderLayersBaseProg::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
 	int ix = x;
 	int iy = y;
diff --git a/source/blender/compositor/operations/COM_RenderLayersBaseProg.h b/source/blender/compositor/operations/COM_RenderLayersBaseProg.h
index a18b515bd7b..ead1eb183b3 100644
--- a/source/blender/compositor/operations/COM_RenderLayersBaseProg.h
+++ b/source/blender/compositor/operations/COM_RenderLayersBaseProg.h
@@ -92,7 +92,7 @@ public:
 	short getLayerId() { return this->m_layerId; }
 	void initExecution();
 	void deinitExecution();
-	void executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]);
+	void executePixel(float *output, float x, float y, PixelSampler sampler);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_RotateOperation.cpp b/source/blender/compositor/operations/COM_RotateOperation.cpp
index 086ce917e7e..a39828e4560 100644
--- a/source/blender/compositor/operations/COM_RotateOperation.cpp
+++ b/source/blender/compositor/operations/COM_RotateOperation.cpp
@@ -52,7 +52,7 @@ inline void RotateOperation::ensureDegree()
 {
 	if (!this->m_isDegreeSet) {
 		float degree[4];
-		this->m_degreeSocket->read(degree, 0, 0, COM_PS_NEAREST, NULL);
+		this->m_degreeSocket->read(degree, 0, 0, COM_PS_NEAREST);
 		double rad;
 		if (this->m_doDegree2RadConversion) {
 			rad = DEG2RAD((double)degree[0]);
@@ -68,14 +68,14 @@ inline void RotateOperation::ensureDegree()
 }
 
 
-void RotateOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void RotateOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	ensureDegree();
 	const float dy = y - this->m_centerY;
 	const float dx = x - this->m_centerX;
 	const float nx = this->m_centerX + (this->m_cosine * dx + this->m_sine * dy);
 	const float ny = this->m_centerY + (-this->m_sine * dx + this->m_cosine * dy);
-	this->m_imageSocket->read(color, nx, ny, sampler, inputBuffers);
+	this->m_imageSocket->read(color, nx, ny, sampler);
 }
 
 bool RotateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
diff --git a/source/blender/compositor/operations/COM_RotateOperation.h b/source/blender/compositor/operations/COM_RotateOperation.h
index 9e6dd3987d1..d011ac0ecc9 100644
--- a/source/blender/compositor/operations/COM_RotateOperation.h
+++ b/source/blender/compositor/operations/COM_RotateOperation.h
@@ -38,7 +38,7 @@ private:
 public:
 	RotateOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	void initExecution();
 	void deinitExecution();
 	void setDoDegree2RadConversion(bool abool) { this->m_doDegree2RadConversion = abool; }
diff --git a/source/blender/compositor/operations/COM_ScaleOperation.cpp b/source/blender/compositor/operations/COM_ScaleOperation.cpp
index 6a1f7b62203..f4a3dc5fa25 100644
--- a/source/blender/compositor/operations/COM_ScaleOperation.cpp
+++ b/source/blender/compositor/operations/COM_ScaleOperation.cpp
@@ -54,7 +54,7 @@ void ScaleOperation::deinitExecution()
 }
 
 
-void ScaleOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ScaleOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 #ifdef USE_FORCE_BICUBIC
 	sampler = COM_PS_BICUBIC;
@@ -63,15 +63,15 @@ void ScaleOperation::executePixel(float *color, float x, float y, PixelSampler s
 	float scaleX[4];
 	float scaleY[4];
 
-	this->m_inputXOperation->read(scaleX, x, y, sampler, inputBuffers);
-	this->m_inputYOperation->read(scaleY, x, y, sampler, inputBuffers);
+	this->m_inputXOperation->read(scaleX, x, y, sampler);
+	this->m_inputYOperation->read(scaleY, x, y, sampler);
 
 	const float scx = scaleX[0];
 	const float scy = scaleY[0];
 
 	float nx = this->m_centerX + (x - this->m_centerX) / scx;
 	float ny = this->m_centerY + (y - this->m_centerY) / scy;
-	this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers);
+	this->m_inputOperation->read(color, nx, ny, sampler);
 }
 
 bool ScaleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
@@ -80,8 +80,8 @@ bool ScaleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe
 	float scaleX[4];
 	float scaleY[4];
 
-	this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST, NULL);
-	this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST, NULL);
+	this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST);
+	this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST);
 
 	const float scx = scaleX[0];
 	const float scy = scaleY[0];
@@ -124,7 +124,7 @@ void ScaleAbsoluteOperation::deinitExecution()
 }
 
 
-void ScaleAbsoluteOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ScaleAbsoluteOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 #ifdef USE_FORCE_BICUBIC
 	sampler = COM_PS_BICUBIC;
@@ -133,8 +133,8 @@ void ScaleAbsoluteOperation::executePixel(float *color, float x, float y, PixelS
 	float scaleX[4];
 	float scaleY[4];
 
-	this->m_inputXOperation->read(scaleX, x, y, sampler, inputBuffers);
-	this->m_inputYOperation->read(scaleY, x, y, sampler, inputBuffers);
+	this->m_inputXOperation->read(scaleX, x, y, sampler);
+	this->m_inputYOperation->read(scaleY, x, y, sampler);
 
 	const float scx = scaleX[0]; // target absolute scale
 	const float scy = scaleY[0]; // target absolute scale
@@ -148,7 +148,7 @@ void ScaleAbsoluteOperation::executePixel(float *color, float x, float y, PixelS
 	float nx = this->m_centerX + (x - this->m_centerX) / relativeXScale;
 	float ny = this->m_centerY + (y - this->m_centerY) / relativeYScale;
 
-	this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers);
+	this->m_inputOperation->read(color, nx, ny, sampler);
 }
 
 bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
@@ -157,8 +157,8 @@ bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadB
 	float scaleX[4];
 	float scaleY[4];
 
-	this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST, NULL);
-	this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST, NULL);
+	this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST);
+	this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST);
 
 	const float scx = scaleX[0];
 	const float scy = scaleY[0];
@@ -244,7 +244,7 @@ void ScaleFixedSizeOperation::deinitExecution()
 }
 
 
-void ScaleFixedSizeOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ScaleFixedSizeOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 #ifdef USE_FORCE_BICUBIC
 	sampler = COM_PS_BICUBIC;
@@ -253,10 +253,10 @@ void ScaleFixedSizeOperation::executePixel(float *color, float x, float y, Pixel
 	if (this->m_is_offset) {
 		float nx = ((x - this->m_offsetX) * this->m_relX);
 		float ny = ((y - this->m_offsetY) * this->m_relY);
-		this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers);
+		this->m_inputOperation->read(color, nx, ny, sampler);
 	}
 	else {
-		this->m_inputOperation->read(color, x * this->m_relX, y * this->m_relY, sampler, inputBuffers);
+		this->m_inputOperation->read(color, x * this->m_relX, y * this->m_relY, sampler);
 	}
 }
 
diff --git a/source/blender/compositor/operations/COM_ScaleOperation.h b/source/blender/compositor/operations/COM_ScaleOperation.h
index 8cd44810bbd..075fb6e7064 100644
--- a/source/blender/compositor/operations/COM_ScaleOperation.h
+++ b/source/blender/compositor/operations/COM_ScaleOperation.h
@@ -35,7 +35,7 @@ private:
 public:
 	ScaleOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
@@ -51,7 +51,7 @@ class ScaleAbsoluteOperation : public NodeOperation {
 public:
 	ScaleAbsoluteOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
@@ -76,7 +76,7 @@ public:
 	ScaleFixedSizeOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
index e70185f8fba..d431ce29554 100644
--- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
+++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
@@ -48,14 +48,14 @@ void ScreenLensDistortionOperation::initExecution()
 	
 }
 
-void *ScreenLensDistortionOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *ScreenLensDistortionOperation::initializeTileData(rcti *rect)
 {
-	void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
-	updateDispersionAndDistortion(memoryBuffers);
+	void *buffer = this->m_inputProgram->initializeTileData(NULL);
+	updateDispersionAndDistortion();
 	return buffer;
 }
 
-void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ScreenLensDistortionOperation::executePixel(float *outputColor, int x, int y, void *data)
 {
 	const float height = this->getHeight();
 	const float width = this->getWidth();
@@ -316,16 +316,16 @@ void ScreenLensDistortionOperation::updateVariables(float distortion, float disp
 	this->m_kb4 = this->m_kb * 4.0f;	
 }
 
-void ScreenLensDistortionOperation::updateDispersionAndDistortion(MemoryBuffer **inputBuffers)
+void ScreenLensDistortionOperation::updateDispersionAndDistortion()
 {
 	if (this->m_valuesAvailable) return;
 	
 	this->lockMutex();
 	if (!this->m_valuesAvailable) {
 		float result[4];
-		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, inputBuffers);
+		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST);
 		this->m_distortion = result[0];
-		this->getInputSocketReader(2)->read(result, 0, 0, COM_PS_NEAREST, inputBuffers);
+		this->getInputSocketReader(2)->read(result, 0, 0, COM_PS_NEAREST);
 		this->m_dispersion = result[0];
 		updateVariables(this->m_distortion, this->m_dispersion);
 		this->m_valuesAvailable = true;
diff --git a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
index f80b938818c..a88717a116e 100644
--- a/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
+++ b/source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
@@ -49,14 +49,14 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	/**
 	 * Deinitialize the execution
 	 */
@@ -81,7 +81,7 @@ public:
 private:
 	void determineUV(float result[4], float x, float y) const;
 	void determineUV(float result[4], float x, float y, float distortion, float dispersion);
-	void updateDispersionAndDistortion(MemoryBuffer **inputBuffers);
+	void updateDispersionAndDistortion();
 	void updateVariables(float distortion, float dispersion);
 
 };
diff --git a/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp b/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp
index 6ae4fc4cfe5..0b080dcc426 100644
--- a/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp
+++ b/source/blender/compositor/operations/COM_SeparateChannelOperation.cpp
@@ -39,9 +39,9 @@ void SeparateChannelOperation::deinitExecution()
 }
 
 
-void SeparateChannelOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SeparateChannelOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float input[4];
-	this->m_inputOperation->read(input, x, y, sampler, inputBuffers);
+	this->m_inputOperation->read(input, x, y, sampler);
 	color[0] = input[this->m_channel];
 }
diff --git a/source/blender/compositor/operations/COM_SeparateChannelOperation.h b/source/blender/compositor/operations/COM_SeparateChannelOperation.h
index 65a54f91252..01fee3ca57d 100644
--- a/source/blender/compositor/operations/COM_SeparateChannelOperation.h
+++ b/source/blender/compositor/operations/COM_SeparateChannelOperation.h
@@ -31,7 +31,7 @@ private:
 	int m_channel;
 public:
 	SeparateChannelOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_SetAlphaOperation.cpp b/source/blender/compositor/operations/COM_SetAlphaOperation.cpp
index d383fb638ae..0f707473f9d 100644
--- a/source/blender/compositor/operations/COM_SetAlphaOperation.cpp
+++ b/source/blender/compositor/operations/COM_SetAlphaOperation.cpp
@@ -38,12 +38,12 @@ void SetAlphaOperation::initExecution()
 	this->m_inputAlpha = getInputSocketReader(1);
 }
 
-void SetAlphaOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SetAlphaOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	float alphaInput[4];
 	
-	this->m_inputColor->read(outputValue, x, y, sampler, inputBuffers);
-	this->m_inputAlpha->read(alphaInput, x, y, sampler, inputBuffers);
+	this->m_inputColor->read(outputValue, x, y, sampler);
+	this->m_inputAlpha->read(alphaInput, x, y, sampler);
 	
 	outputValue[3] = alphaInput[0];
 }
diff --git a/source/blender/compositor/operations/COM_SetAlphaOperation.h b/source/blender/compositor/operations/COM_SetAlphaOperation.h
index 21968c930e7..3d8eb5b9493 100644
--- a/source/blender/compositor/operations/COM_SetAlphaOperation.h
+++ b/source/blender/compositor/operations/COM_SetAlphaOperation.h
@@ -43,7 +43,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_SetColorOperation.cpp b/source/blender/compositor/operations/COM_SetColorOperation.cpp
index 55a6a3800ca..0665073840c 100644
--- a/source/blender/compositor/operations/COM_SetColorOperation.cpp
+++ b/source/blender/compositor/operations/COM_SetColorOperation.cpp
@@ -27,7 +27,7 @@ SetColorOperation::SetColorOperation() : NodeOperation()
 	this->addOutputSocket(COM_DT_COLOR);
 }
 
-void SetColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SetColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	outputValue[0] = this->m_channel1;
 	outputValue[1] = this->m_channel2;
diff --git a/source/blender/compositor/operations/COM_SetColorOperation.h b/source/blender/compositor/operations/COM_SetColorOperation.h
index a51311837ee..72708800f1e 100644
--- a/source/blender/compositor/operations/COM_SetColorOperation.h
+++ b/source/blender/compositor/operations/COM_SetColorOperation.h
@@ -61,7 +61,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 	const bool isSetOperation() const { return true; }
diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.cpp b/source/blender/compositor/operations/COM_SetSamplerOperation.cpp
index c235bd81e58..f7c1ef8f6f5 100644
--- a/source/blender/compositor/operations/COM_SetSamplerOperation.cpp
+++ b/source/blender/compositor/operations/COM_SetSamplerOperation.cpp
@@ -37,7 +37,7 @@ void SetSamplerOperation::deinitExecution()
 	this->m_reader = NULL;
 }
 
-void SetSamplerOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SetSamplerOperation::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
-	this->m_reader->read(output, x, y, this->m_sampler, inputBuffers);
+	this->m_reader->read(output, x, y, this->m_sampler);
 }
diff --git a/source/blender/compositor/operations/COM_SetSamplerOperation.h b/source/blender/compositor/operations/COM_SetSamplerOperation.h
index 273eac159bc..7b53cd8d38e 100644
--- a/source/blender/compositor/operations/COM_SetSamplerOperation.h
+++ b/source/blender/compositor/operations/COM_SetSamplerOperation.h
@@ -44,7 +44,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	void initExecution();
 	void deinitExecution();
 };
diff --git a/source/blender/compositor/operations/COM_SetValueOperation.cpp b/source/blender/compositor/operations/COM_SetValueOperation.cpp
index 98a21112c5b..d88257226f5 100644
--- a/source/blender/compositor/operations/COM_SetValueOperation.cpp
+++ b/source/blender/compositor/operations/COM_SetValueOperation.cpp
@@ -27,7 +27,7 @@ SetValueOperation::SetValueOperation() : NodeOperation()
 	this->addOutputSocket(COM_DT_VALUE);
 }
 
-void SetValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SetValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	outputValue[0] = this->m_value;
 }
diff --git a/source/blender/compositor/operations/COM_SetValueOperation.h b/source/blender/compositor/operations/COM_SetValueOperation.h
index 642940e03cd..a2c3e8eaa0b 100644
--- a/source/blender/compositor/operations/COM_SetValueOperation.h
+++ b/source/blender/compositor/operations/COM_SetValueOperation.h
@@ -46,7 +46,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 	
 	const bool isSetOperation() const { return true; }
diff --git a/source/blender/compositor/operations/COM_SetVectorOperation.cpp b/source/blender/compositor/operations/COM_SetVectorOperation.cpp
index f37bc489e75..651add0453f 100644
--- a/source/blender/compositor/operations/COM_SetVectorOperation.cpp
+++ b/source/blender/compositor/operations/COM_SetVectorOperation.cpp
@@ -28,7 +28,7 @@ SetVectorOperation::SetVectorOperation() : NodeOperation()
 	this->addOutputSocket(COM_DT_VECTOR);
 }
 
-void SetVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SetVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
 	outputValue[0] = this->m_x;
 	outputValue[1] = this->m_y;
diff --git a/source/blender/compositor/operations/COM_SetVectorOperation.h b/source/blender/compositor/operations/COM_SetVectorOperation.h
index d1b9fe25085..0868213a109 100644
--- a/source/blender/compositor/operations/COM_SetVectorOperation.h
+++ b/source/blender/compositor/operations/COM_SetVectorOperation.h
@@ -54,7 +54,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 	const bool isSetOperation() const { return true; }
diff --git a/source/blender/compositor/operations/COM_SocketProxyOperation.cpp b/source/blender/compositor/operations/COM_SocketProxyOperation.cpp
index 8b39406fd83..0e670d9268e 100644
--- a/source/blender/compositor/operations/COM_SocketProxyOperation.cpp
+++ b/source/blender/compositor/operations/COM_SocketProxyOperation.cpp
@@ -39,9 +39,9 @@ void SocketProxyOperation::deinitExecution()
 	this->m_inputOperation = NULL;
 }
 
-void SocketProxyOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void SocketProxyOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	if (this->m_inputOperation) {
-		this->m_inputOperation->read(color, x, y, sampler, inputBuffers);
+		this->m_inputOperation->read(color, x, y, sampler);
 	}
 }
diff --git a/source/blender/compositor/operations/COM_SocketProxyOperation.h b/source/blender/compositor/operations/COM_SocketProxyOperation.h
index a4177efbd8e..219483aa92d 100644
--- a/source/blender/compositor/operations/COM_SocketProxyOperation.h
+++ b/source/blender/compositor/operations/COM_SocketProxyOperation.h
@@ -30,7 +30,7 @@ private:
 	SocketReader *m_inputOperation;
 public:
 	SocketProxyOperation(DataType type);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	
 	void initExecution();
 	void deinitExecution();
diff --git a/source/blender/compositor/operations/COM_SplitViewerOperation.cpp b/source/blender/compositor/operations/COM_SplitViewerOperation.cpp
index 6236a666260..80de4e71fce 100644
--- a/source/blender/compositor/operations/COM_SplitViewerOperation.cpp
+++ b/source/blender/compositor/operations/COM_SplitViewerOperation.cpp
@@ -80,10 +80,10 @@ void SplitViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 			float srgb[4];
 			image1 = this->m_xSplit ? x > perc : y > perc;
 			if (image1) {
-				this->m_image1Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST, NULL);
+				this->m_image1Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST);
 			}
 			else {
-				this->m_image2Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST, NULL);
+				this->m_image2Input->read(&(buffer[offset]), x, y, COM_PS_NEAREST);
 			}
 			/// @todo: linear conversion only when scene color management is selected, also check predivide.
 			if (this->m_doColorManagement) {
diff --git a/source/blender/compositor/operations/COM_TextureOperation.cpp b/source/blender/compositor/operations/COM_TextureOperation.cpp
index 6098cfc3e5c..4cf935799cb 100644
--- a/source/blender/compositor/operations/COM_TextureOperation.cpp
+++ b/source/blender/compositor/operations/COM_TextureOperation.cpp
@@ -68,16 +68,16 @@ void TextureBaseOperation::determineResolution(unsigned int resolution[], unsign
 	}
 }
 
-void TextureAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void TextureAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
-	TextureBaseOperation::executePixel(color, x, y, sampler, inputBuffers);
+	TextureBaseOperation::executePixel(color, x, y, sampler);
 	color[0] = color[3];
 	color[1] = 0.0f;
 	color[2] = 0.0f;
 	color[3] = 0.0f;
 }
 
-void TextureBaseOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void TextureBaseOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	TexResult texres = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0, NULL};
 	float textureSize[4];
@@ -89,8 +89,8 @@ void TextureBaseOperation::executePixel(float *color, float x, float y, PixelSam
 	const float u = (cx - x) / this->getWidth() * 2;
 	const float v = (cy - y) / this->getHeight() * 2;
 
-	this->m_inputSize->read(textureSize, x, y, sampler, inputBuffers);
-	this->m_inputOffset->read(textureOffset, x, y, sampler, inputBuffers);
+	this->m_inputSize->read(textureSize, x, y, sampler);
+	this->m_inputOffset->read(textureOffset, x, y, sampler);
 
 	vec[0] = textureSize[0] * (u + textureOffset[0]);
 	vec[1] = textureSize[1] * (v + textureOffset[1]);
diff --git a/source/blender/compositor/operations/COM_TextureOperation.h b/source/blender/compositor/operations/COM_TextureOperation.h
index d42da697b08..8735aff19dc 100644
--- a/source/blender/compositor/operations/COM_TextureOperation.h
+++ b/source/blender/compositor/operations/COM_TextureOperation.h
@@ -60,7 +60,7 @@ protected:
 	TextureBaseOperation();
 
 public:
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void setTexture(Tex *texture) { this->m_texture = texture; }
 	void initExecution();
@@ -76,7 +76,7 @@ public:
 class TextureAlphaOperation : public TextureBaseOperation {
 public:
 	TextureAlphaOperation();
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 
diff --git a/source/blender/compositor/operations/COM_TonemapOperation.cpp b/source/blender/compositor/operations/COM_TonemapOperation.cpp
index b5daf85b390..0dc30ebfcb9 100644
--- a/source/blender/compositor/operations/COM_TonemapOperation.cpp
+++ b/source/blender/compositor/operations/COM_TonemapOperation.cpp
@@ -41,12 +41,12 @@ void TonemapOperation::initExecution()
 	NodeOperation::initMutex();
 }
 
-void TonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void TonemapOperation::executePixel(float *color, int x, int y, void *data)
 {
 	AvgLogLum *avg = (AvgLogLum *)data;
 
 	float output[4];
-	this->m_imageReader->read(output, x, y, inputBuffers, NULL);
+	this->m_imageReader->read(output, x, y, NULL);
 	mul_v3_fl(output, avg->al);
 	float dr = output[0] + this->m_data->offset;
 	float dg = output[1] + this->m_data->offset;
@@ -63,7 +63,7 @@ void TonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *in
 
 	copy_v4_v4(color, output);
 }
-void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, void *data)
 {
 	AvgLogLum *avg = (AvgLogLum *)data;
 	NodeTonemap *ntm = this->m_data;
@@ -73,7 +73,7 @@ void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, Mem
 	const float ic = 1.0f - ntm->c, ia = 1.0f - ntm->a;
 
 	float output[4];
-	this->m_imageReader->read(output, x, y, inputBuffers, NULL);
+	this->m_imageReader->read(output, x, y, NULL);
 
 	const float L = rgb_to_luma_y(output);
 	float I_l = output[0] + ic * (L - output[0]);
@@ -116,11 +116,11 @@ bool TonemapOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferO
 	return false;
 }
 
-void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *TonemapOperation::initializeTileData(rcti *rect)
 {
 	lockMutex();
 	if (this->m_cachedInstance == NULL) {
-		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect);
 		AvgLogLum *data = new AvgLogLum();
 
 		float *buffer = tile->getBuffer();
@@ -154,7 +154,7 @@ void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuff
 	return this->m_cachedInstance;
 }
 
-void TonemapOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
+void TonemapOperation::deinitializeTileData(rcti *rect, void *data)
 {
 	/* pass */
 }
diff --git a/source/blender/compositor/operations/COM_TonemapOperation.h b/source/blender/compositor/operations/COM_TonemapOperation.h
index ed9018d0a09..4e591276c76 100644
--- a/source/blender/compositor/operations/COM_TonemapOperation.h
+++ b/source/blender/compositor/operations/COM_TonemapOperation.h
@@ -64,15 +64,15 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-	void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+	void *initializeTileData(rcti *rect);
+	void deinitializeTileData(rcti *rect, void *data);
 	
 	/**
 	 * Deinitialize the execution
@@ -97,7 +97,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_TranslateOperation.cpp b/source/blender/compositor/operations/COM_TranslateOperation.cpp
index e43a8e55130..fda50ac24d1 100644
--- a/source/blender/compositor/operations/COM_TranslateOperation.cpp
+++ b/source/blender/compositor/operations/COM_TranslateOperation.cpp
@@ -50,10 +50,10 @@ void TranslateOperation::deinitExecution()
 }
 
 
-void TranslateOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void TranslateOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	ensureDelta();
-	this->m_inputOperation->read(color, x - this->getDeltaX(), y - this->getDeltaY(), sampler, inputBuffers);
+	this->m_inputOperation->read(color, x - this->getDeltaX(), y - this->getDeltaY(), sampler);
 }
 
 bool TranslateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
diff --git a/source/blender/compositor/operations/COM_TranslateOperation.h b/source/blender/compositor/operations/COM_TranslateOperation.h
index 8af4ffe8967..83e3befdfeb 100644
--- a/source/blender/compositor/operations/COM_TranslateOperation.h
+++ b/source/blender/compositor/operations/COM_TranslateOperation.h
@@ -36,7 +36,7 @@ private:
 public:
 	TranslateOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 	void initExecution();
 	void deinitExecution();
@@ -47,9 +47,9 @@ public:
 	inline void ensureDelta() {
 		if (!this->m_isDeltaSet) {
 			float tempDelta[4];
-			this->m_inputXOperation->read(tempDelta, 0, 0, COM_PS_NEAREST, NULL);
+			this->m_inputXOperation->read(tempDelta, 0, 0, COM_PS_NEAREST);
 			this->m_deltaX = tempDelta[0];
-			this->m_inputYOperation->read(tempDelta, 0, 0, COM_PS_NEAREST, NULL);
+			this->m_inputYOperation->read(tempDelta, 0, 0, COM_PS_NEAREST);
 			this->m_deltaY = tempDelta[0];
 			this->m_isDeltaSet = true;
 		}
diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
index 99a8e563c69..8faa571dc38 100644
--- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
@@ -62,22 +62,22 @@ void VariableSizeBokehBlurOperation::initExecution()
 	QualityStepHelper::initExecution(COM_QH_INCREASE);
 }
 
-void *VariableSizeBokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *VariableSizeBokehBlurOperation::initializeTileData(rcti *rect)
 {
 	MemoryBuffer** result = new MemoryBuffer*[3];
-	result[0] = (MemoryBuffer*)this->m_inputProgram->initializeTileData(rect, memoryBuffers);
-	result[1] = (MemoryBuffer*)this->m_inputBokehProgram->initializeTileData(rect, memoryBuffers);
-	result[2] = (MemoryBuffer*)this->m_inputSizeProgram->initializeTileData(rect, memoryBuffers);
+	result[0] = (MemoryBuffer*)this->m_inputProgram->initializeTileData(rect);
+	result[1] = (MemoryBuffer*)this->m_inputBokehProgram->initializeTileData(rect);
+	result[2] = (MemoryBuffer*)this->m_inputSizeProgram->initializeTileData(rect);
 	return result;
 }
 
-void VariableSizeBokehBlurOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
+void VariableSizeBokehBlurOperation::deinitializeTileData(rcti *rect, void *data)
 {
 	MemoryBuffer** result = (MemoryBuffer**)data;
 	delete[] result;
 }
 
-void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	MemoryBuffer** buffers = (MemoryBuffer**)data;
 	MemoryBuffer* inputProgramBuffer = buffers[0];
@@ -93,7 +93,7 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
 
 #ifdef COM_DEFOCUS_SEARCH
 	float search[4];
-	this->m_inputSearchProgram->read(search, x/InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, inputBuffers, NULL);
+	this->m_inputSearchProgram->read(search, x/InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, NULL);
 	int minx = search[0];
 	int miny = search[1];
 	int maxx = search[2];
@@ -238,7 +238,7 @@ void InverseSearchRadiusOperation::initExecution()
 	this->m_inputRadius = this->getInputSocketReader(0);
 }
 
-void* InverseSearchRadiusOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) 
+void* InverseSearchRadiusOperation::initializeTileData(rcti *rect) 
 {
 	MemoryBuffer * data = new MemoryBuffer(NULL, rect);
 	float* buffer = data->getBuffer();
@@ -268,7 +268,7 @@ void* InverseSearchRadiusOperation::initializeTileData(rcti *rect, MemoryBuffer
 	
 //			for (int x2 = 0 ; x2 < DIVIDER ; x2 ++) {
 //				for (int y2 = 0 ; y2 < DIVIDER ; y2 ++) {
-//					this->m_inputRadius->read(temp, rx+x2, ry+y2, COM_PS_NEAREST, NULL);
+//					this->m_inputRadius->read(temp, rx+x2, ry+y2, COM_PS_NEAREST);
 //					if (radius < temp[0]) {
 //						radius = temp[0];
 //						maxx = x2;
@@ -292,13 +292,13 @@ void* InverseSearchRadiusOperation::initializeTileData(rcti *rect, MemoryBuffer
 	return data;
 }
 
-void InverseSearchRadiusOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) 
+void InverseSearchRadiusOperation::executePixel(float *color, int x, int y, void *data) 
 {
 	MemoryBuffer *buffer = (MemoryBuffer*)data;
 	buffer->readNoCheck(color, x, y);
 }
 
-void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data) 
+void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, void *data) 
 {
 	if (data) {
 		MemoryBuffer* mb = (MemoryBuffer*)data;
diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
index f283e60572e..e5430545323 100644
--- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
+++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
@@ -44,16 +44,16 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
 	 */
 	void initExecution();
 	
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 	
-	void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+	void deinitializeTileData(rcti *rect, void *data);
 	
 	/**
 	 * Deinitialize the execution
@@ -88,8 +88,8 @@ public:
 	 * Initialize the execution
 	 */
 	void initExecution();
-	void* initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-	void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+	void* initializeTileData(rcti *rect);
+	void deinitializeTileData(rcti *rect, void *data);
 	
 	/**
 	 * Deinitialize the execution
diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.cpp b/source/blender/compositor/operations/COM_VectorBlurOperation.cpp
index 48be72561ba..8934dd80ad8 100644
--- a/source/blender/compositor/operations/COM_VectorBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_VectorBlurOperation.cpp
@@ -52,7 +52,7 @@ void VectorBlurOperation::initExecution()
 	
 }
 
-void VectorBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void VectorBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
 	float *buffer = (float *) data;
 	int index = (y * this->getWidth() + x) * COM_NUMBER_OF_CHANNELS;
@@ -70,7 +70,7 @@ void VectorBlurOperation::deinitExecution()
 		this->m_cachedInstance = NULL;
 	}
 }
-void *VectorBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *VectorBlurOperation::initializeTileData(rcti *rect)
 {
 	if (this->m_cachedInstance) {
 		return this->m_cachedInstance;
@@ -78,9 +78,9 @@ void *VectorBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryB
 	
 	lockMutex();
 	if (this->m_cachedInstance == NULL) {
-		MemoryBuffer *tile = (MemoryBuffer *)this->m_inputImageProgram->initializeTileData(rect, memoryBuffers);
-		MemoryBuffer *speed = (MemoryBuffer *)this->m_inputSpeedProgram->initializeTileData(rect, memoryBuffers);
-		MemoryBuffer *z = (MemoryBuffer *)this->m_inputZProgram->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *tile = (MemoryBuffer *)this->m_inputImageProgram->initializeTileData(rect);
+		MemoryBuffer *speed = (MemoryBuffer *)this->m_inputSpeedProgram->initializeTileData(rect);
+		MemoryBuffer *z = (MemoryBuffer *)this->m_inputZProgram->initializeTileData(rect);
 		float *data = new float[this->getWidth() * this->getHeight() * COM_NUMBER_OF_CHANNELS];
 		memcpy(data, tile->getBuffer(), this->getWidth() * this->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float));
 		this->generateVectorBlur(data, tile, speed, z);
diff --git a/source/blender/compositor/operations/COM_VectorBlurOperation.h b/source/blender/compositor/operations/COM_VectorBlurOperation.h
index a2e72fa3232..2743baf8500 100644
--- a/source/blender/compositor/operations/COM_VectorBlurOperation.h
+++ b/source/blender/compositor/operations/COM_VectorBlurOperation.h
@@ -48,7 +48,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+	void executePixel(float *color, int x, int y, void *data);
 	
 	/**
 	 * Initialize the execution
@@ -60,7 +60,7 @@ public:
 	 */
 	void deinitExecution();
 
-	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+	void *initializeTileData(rcti *rect);
 
 	void setVectorBlurSettings(NodeBlurData *settings) { this->m_settings = settings; }
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.cpp b/source/blender/compositor/operations/COM_VectorCurveOperation.cpp
index ee3f44d8979..ed86c842fc9 100644
--- a/source/blender/compositor/operations/COM_VectorCurveOperation.cpp
+++ b/source/blender/compositor/operations/COM_VectorCurveOperation.cpp
@@ -43,12 +43,12 @@ void VectorCurveOperation::initExecution()
 	this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void VectorCurveOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void VectorCurveOperation::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
 	float input[4];
 
 
-	this->m_inputProgram->read(input, x, y, sampler, inputBuffers);
+	this->m_inputProgram->read(input, x, y, sampler);
 
 	curvemapping_evaluate_premulRGBF(this->m_curveMapping, output, input);
 	output[3] = input[3];
diff --git a/source/blender/compositor/operations/COM_VectorCurveOperation.h b/source/blender/compositor/operations/COM_VectorCurveOperation.h
index 2fbaf170986..b76f8880fc6 100644
--- a/source/blender/compositor/operations/COM_VectorCurveOperation.h
+++ b/source/blender/compositor/operations/COM_VectorCurveOperation.h
@@ -37,7 +37,7 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *Vector, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *Vector, float x, float y, PixelSampler sampler);
 	
 	/**
 	 * Initialize the execution
diff --git a/source/blender/compositor/operations/COM_ViewerOperation.cpp b/source/blender/compositor/operations/COM_ViewerOperation.cpp
index fdf9c49b112..f7c2ff93b3e 100644
--- a/source/blender/compositor/operations/COM_ViewerOperation.cpp
+++ b/source/blender/compositor/operations/COM_ViewerOperation.cpp
@@ -82,12 +82,11 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 
 	for (y = y1; y < y2 && (!breaked); y++) {
 		for (x = x1; x < x2; x++) {
-			this->m_imageInput->read(&(buffer[offset]), x, y, COM_PS_NEAREST, NULL);
+			this->m_imageInput->read(&(buffer[offset]), x, y, COM_PS_NEAREST);
 			if (this->m_alphaInput != NULL) {
-				this->m_alphaInput->read(alpha, x, y, COM_PS_NEAREST, NULL);
+				this->m_alphaInput->read(alpha, x, y, COM_PS_NEAREST);
 				buffer[offset + 3] = alpha[0];
 			}
-			/// @todo: linear conversion only when scene color management is selected, also check predivide.
 			if (this->m_doColorManagement) {
 				if (this->m_doColorPredivide) {
 					linearrgb_to_srgb_predivide_v4(srgb, buffer + offset);
diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.cpp b/source/blender/compositor/operations/COM_WriteBufferOperation.cpp
index 17e51bf08f2..0a31a6e170b 100644
--- a/source/blender/compositor/operations/COM_WriteBufferOperation.cpp
+++ b/source/blender/compositor/operations/COM_WriteBufferOperation.cpp
@@ -40,9 +40,9 @@ WriteBufferOperation::~WriteBufferOperation()
 	}
 }
 
-void WriteBufferOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void WriteBufferOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
-	this->m_input->read(color, x, y, sampler, inputBuffers);
+	this->m_input->read(color, x, y, sampler);
 }
 
 void WriteBufferOperation::initExecution()
@@ -62,7 +62,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 	MemoryBuffer *memoryBuffer = this->m_memoryProxy->getBuffer();
 	float *buffer = memoryBuffer->getBuffer();
 	if (this->m_input->isComplex()) {
-		void *data = this->m_input->initializeTileData(rect, NULL);
+		void *data = this->m_input->initializeTileData(rect);
 		int x1 = rect->xmin;
 		int y1 = rect->ymin;
 		int x2 = rect->xmax;
@@ -73,7 +73,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 		for (y = y1; y < y2 && (!breaked); y++) {
 			int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS;
 			for (x = x1; x < x2; x++) {
-				this->m_input->read(&(buffer[offset4]), x, y, NULL, data);
+				this->m_input->read(&(buffer[offset4]), x, y, data);
 				offset4 += COM_NUMBER_OF_CHANNELS;
 
 			}
@@ -83,7 +83,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 
 		}
 		if (data) {
-			this->m_input->deinitializeTileData(rect, NULL, data);
+			this->m_input->deinitializeTileData(rect, data);
 			data = NULL;
 		}
 	}
@@ -99,7 +99,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 		for (y = y1; y < y2 && (!breaked); y++) {
 			int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS;
 			for (x = x1; x < x2; x++) {
-				this->m_input->read(&(buffer[offset4]), x, y, COM_PS_NEAREST, NULL);
+				this->m_input->read(&(buffer[offset4]), x, y, COM_PS_NEAREST);
 				offset4 += COM_NUMBER_OF_CHANNELS;
 			}
 			if (isBreaked()) {
diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.h b/source/blender/compositor/operations/COM_WriteBufferOperation.h
index 0e0dc279c2c..1aa93c658cb 100644
--- a/source/blender/compositor/operations/COM_WriteBufferOperation.h
+++ b/source/blender/compositor/operations/COM_WriteBufferOperation.h
@@ -38,7 +38,7 @@ public:
 	~WriteBufferOperation();
 	int isBufferOperation() { return true; }
 	MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; }
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 	const bool isWriteBufferOperation() const { return true; }
 	
 	void executeRegion(rcti *rect, unsigned int tileNumber);
diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.cpp b/source/blender/compositor/operations/COM_ZCombineOperation.cpp
index c1ea63432b9..28dbcd9f017 100644
--- a/source/blender/compositor/operations/COM_ZCombineOperation.cpp
+++ b/source/blender/compositor/operations/COM_ZCombineOperation.cpp
@@ -46,36 +46,36 @@ void ZCombineOperation::initExecution()
 	this->m_depth2Reader = this->getInputSocketReader(3);
 }
 
-void ZCombineOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ZCombineOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float depth1[4];
 	float depth2[4];
 
-	this->m_depth1Reader->read(depth1, x, y, sampler, inputBuffers);
-	this->m_depth2Reader->read(depth2, x, y, sampler, inputBuffers);
+	this->m_depth1Reader->read(depth1, x, y, sampler);
+	this->m_depth2Reader->read(depth2, x, y, sampler);
 	if (depth1[0] < depth2[0]) {
-		this->m_image1Reader->read(color, x, y, sampler, inputBuffers);
+		this->m_image1Reader->read(color, x, y, sampler);
 	}
 	else {
-		this->m_image2Reader->read(color, x, y, sampler, inputBuffers);
+		this->m_image2Reader->read(color, x, y, sampler);
 	}
 }
-void ZCombineAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ZCombineAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
 	float depth1[4];
 	float depth2[4];
 	float color1[4];
 	float color2[4];
 
-	this->m_depth1Reader->read(depth1, x, y, sampler, inputBuffers);
-	this->m_depth2Reader->read(depth2, x, y, sampler, inputBuffers);
+	this->m_depth1Reader->read(depth1, x, y, sampler);
+	this->m_depth2Reader->read(depth2, x, y, sampler);
 	if (depth1[0] < depth2[0]) {
-		this->m_image1Reader->read(color1, x, y, sampler, inputBuffers);
-		this->m_image2Reader->read(color2, x, y, sampler, inputBuffers);
+		this->m_image1Reader->read(color1, x, y, sampler);
+		this->m_image2Reader->read(color2, x, y, sampler);
 	}
 	else {
-		this->m_image1Reader->read(color2, x, y, sampler, inputBuffers);
-		this->m_image2Reader->read(color1, x, y, sampler, inputBuffers);
+		this->m_image1Reader->read(color2, x, y, sampler);
+		this->m_image2Reader->read(color1, x, y, sampler);
 	}
 	float fac = color1[3];
 	float ifac = 1.0f - fac;
diff --git a/source/blender/compositor/operations/COM_ZCombineOperation.h b/source/blender/compositor/operations/COM_ZCombineOperation.h
index 422a946b98f..9ee0899ee28 100644
--- a/source/blender/compositor/operations/COM_ZCombineOperation.h
+++ b/source/blender/compositor/operations/COM_ZCombineOperation.h
@@ -47,11 +47,11 @@ public:
 	/**
 	 * the inner loop of this program
 	 */
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 class ZCombineAlphaOperation : public ZCombineOperation {
-	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+	void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif