Merged changes in the trunk up to revision 47700.

Conflicts resolved:
source/blender/blenkernel/BKE_main.h
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/intern/library.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/editors/interface/resources.c
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/SConscript
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_main.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/windowmanager/WM_types.h

40 files changed, 636 insertions, 220 deletions

diff --git a/source/blender/compositor/operations/COM_BlurBaseOperation.cpp b/source/blender/compositor/operations/COM_BlurBaseOperation.cpp
index babea459d6a..2280ee3a435 100644
--- a/source/blender/compositor/operations/COM_BlurBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_BlurBaseOperation.cpp
@@ -101,7 +101,10 @@ void BlurBaseOperation::deinitExecution()
 
 void BlurBaseOperation::updateSize(MemoryBuffer **memoryBuffers)
 {
-	float result[4];
-	this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers);
-	this->size = result[0];
+	if (!this->sizeavailable) {
+		float result[4];
+		this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers);
+		this->size = result[0];
+		this->sizeavailable = true;
+	}
 }
diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.cpp b/source/blender/compositor/operations/COM_BokehBlurOperation.cpp
index 1050fc57194..71a87dce2a7 100644
--- a/source/blender/compositor/operations/COM_BokehBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_BokehBlurOperation.cpp
@@ -34,8 +34,9 @@ BokehBlurOperation::BokehBlurOperation() : NodeOperation()
 	this->addInputSocket(COM_DT_VALUE);
 	this->addOutputSocket(COM_DT_COLOR);
 	this->setComplex(true);
+	this->setOpenCL(true);
 
-	this->size = .01;
+	this->size = 1.0f;
 
 	this->inputProgram = NULL;
 	this->inputBokehProgram = NULL;
@@ -90,7 +91,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
 		int bufferwidth = inputBuffer->getWidth();
 		int bufferstartx = inputBuffer->getRect()->xmin;
 		int bufferstarty = inputBuffer->getRect()->ymin;
-		int pixelSize = this->size*this->getWidth();
+		int pixelSize = this->size*this->getWidth()/100.0f;
 
 		int miny = y - pixelSize;
 		int maxy = y + pixelSize;
@@ -120,9 +121,9 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
 				bufferindex +=offsetadd;
 			}
 		}
-		color[0] = tempColor[0]*(1.0/overallmultiplyerr);
-		color[1] = tempColor[1]*(1.0/overallmultiplyerg);
-		color[2] = tempColor[2]*(1.0/overallmultiplyerb);
+		color[0] = tempColor[0] * (1.0f / overallmultiplyerr);
+		color[1] = tempColor[1] * (1.0f / overallmultiplyerg);
+		color[2] = tempColor[2] * (1.0f / overallmultiplyerb);
 		color[3] = 1.0f;
 	}
 	else {
@@ -142,10 +143,10 @@ bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe
 	rcti newInput;
 	rcti bokehInput;
 
-	newInput.xmax = input->xmax + (size*this->getWidth());
-	newInput.xmin = input->xmin - (size*this->getWidth());
-	newInput.ymax = input->ymax + (size*this->getWidth());
-	newInput.ymin = input->ymin - (size*this->getWidth());
+	newInput.xmax = input->xmax + (size*this->getWidth()/100.0f);
+	newInput.xmin = input->xmin - (size*this->getWidth()/100.0f);
+	newInput.ymax = input->ymax + (size*this->getWidth()/100.0f);
+	newInput.ymin = input->ymin - (size*this->getWidth()/100.0f);
 
 	NodeOperation *operation = getInputOperation(1);
 	bokehInput.xmax = operation->getWidth();
@@ -165,3 +166,27 @@ bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe
 	}
 	return false;
 }
+
+static cl_kernel kernel = 0;
+void BokehBlurOperation::executeOpenCL(cl_context context, cl_program program, cl_command_queue queue, 
+                                       MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer, 
+                                       MemoryBuffer **inputMemoryBuffers, list<cl_mem> *clMemToCleanUp, 
+                                       list<cl_kernel> *clKernelsToCleanUp) 
+{
+	if (!kernel) {
+		kernel = COM_clCreateKernel(program, "bokehBlurKernel", NULL);
+	}
+	cl_int radius = this->getWidth()*this->size/100.0f;
+	cl_int step = this->getStep();
+	
+	COM_clAttachMemoryBufferToKernelParameter(context, kernel, 0, -1, clMemToCleanUp, inputMemoryBuffers, this->inputBoundingBoxReader);
+	COM_clAttachMemoryBufferToKernelParameter(context, kernel, 1,  4, clMemToCleanUp, inputMemoryBuffers, this->inputProgram);
+	COM_clAttachMemoryBufferToKernelParameter(context, kernel, 2,  -1, clMemToCleanUp, inputMemoryBuffers, this->inputBokehProgram);
+	COM_clAttachOutputMemoryBufferToKernelParameter(kernel, 3, clOutputBuffer);
+	COM_clAttachMemoryBufferOffsetToKernelParameter(kernel, 5, outputMemoryBuffer);
+	clSetKernelArg(kernel, 6, sizeof(cl_int), &radius);
+	clSetKernelArg(kernel, 7, sizeof(cl_int), &step);
+	COM_clAttachSizeToKernelParameter(kernel, 8);
+	
+	COM_clEnqueueRange(queue, kernel, outputMemoryBuffer, 9);	
+}
diff --git a/source/blender/compositor/operations/COM_BokehBlurOperation.h b/source/blender/compositor/operations/COM_BokehBlurOperation.h
index ce14faa8596..3cdd995b1df 100644
--- a/source/blender/compositor/operations/COM_BokehBlurOperation.h
+++ b/source/blender/compositor/operations/COM_BokehBlurOperation.h
@@ -56,5 +56,7 @@ public:
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
 	void setSize(float size) {this->size = size;}
+	
+	void executeOpenCL(cl_context context, cl_program program, cl_command_queue queue, MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer, MemoryBuffer **inputMemoryBuffers, list<cl_mem> *clMemToCleanUp, list<cl_kernel> *clKernelsToCleanUp);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.cpp b/source/blender/compositor/operations/COM_BokehImageOperation.cpp
index 0279b9a5bdf..a0297b12961 100644
--- a/source/blender/compositor/operations/COM_BokehImageOperation.cpp
+++ b/source/blender/compositor/operations/COM_BokehImageOperation.cpp
@@ -34,25 +34,25 @@ void BokehImageOperation::initExecution()
 	this->centerY = getHeight() / 2;
 	this->center[0] = this->centerX;
 	this->center[1] = this->centerY;
-	this->inverseRounding = 1.0-this->data->rounding;
+	this->inverseRounding = 1.0f - this->data->rounding;
 	this->circularDistance = getWidth()/2;
-	this->flapRad = (M_PI*2)/this->data->flaps;
-	this->flapRadAdd = (this->data->angle/360.0)*M_PI*2;
-	while (this->flapRadAdd<0.0f) {
-		this->flapRadAdd+=M_PI*2;
+	this->flapRad = (float)(M_PI * 2) / this->data->flaps;
+	this->flapRadAdd = (this->data->angle / 360.0f) * (float)(M_PI * 2.0);
+	while (this->flapRadAdd < 0.0f) {
+		this->flapRadAdd += (float)(M_PI * 2.0);
 	}
-	while (this->flapRadAdd>M_PI) {
-		this->flapRadAdd-=M_PI*2;
+	while (this->flapRadAdd > (float)M_PI) {
+		this->flapRadAdd -= (float)(M_PI * 2.0);
 	}
 }
 void BokehImageOperation::detemineStartPointOfFlap(float r[2], int flapNumber, float distance)
 {
-	r[0] = sin(flapRad*flapNumber + flapRadAdd)*distance+centerX;
-	r[1] = cos(flapRad*flapNumber + flapRadAdd)*distance+centerY;
+	r[0] = sinf(flapRad * flapNumber + flapRadAdd) * distance + centerX;
+	r[1] = cosf(flapRad * flapNumber + flapRadAdd) * distance + centerY;
 }
 float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
 {
-	float insideBokeh = 0.0;
+	float insideBokeh = 0.0f;
 	const float deltaX = x - centerX;
 	const float deltaY = y - centerY;
 	float closestPoint[2];
@@ -63,7 +63,7 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
 	point[1] = y;
 
 	const float distanceToCenter = len_v2v2(point, center);
-	const float bearing = (atan2f(deltaX, deltaY) + (M_PI*2));
+	const float bearing = (atan2f(deltaX, deltaY) + (float)(M_PI * 2.0));
 	int flapNumber = (int)((bearing-flapRadAdd)/flapRad);
 
 	detemineStartPointOfFlap(lineP1, flapNumber, distance);
@@ -73,16 +73,16 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
 	const float distanceLineToCenter = len_v2v2(center, closestPoint);
 	const float distanceRoundingToCenter = inverseRounding*distanceLineToCenter+this->data->rounding*distance;
 
-	const float catadioptricDistanceToCenter = distanceRoundingToCenter*this->data->catadioptric;
-	if (distanceRoundingToCenter>=distanceToCenter && catadioptricDistanceToCenter<=distanceToCenter) {
-		if (distanceRoundingToCenter-distanceToCenter<1.0) {
+	const float catadioptricDistanceToCenter = distanceRoundingToCenter * this->data->catadioptric;
+	if (distanceRoundingToCenter>=distanceToCenter && catadioptricDistanceToCenter <= distanceToCenter) {
+		if (distanceRoundingToCenter - distanceToCenter < 1.0f) {
 			insideBokeh = (distanceRoundingToCenter-distanceToCenter);
 		}
-		else if (this->data->catadioptric != 0.0 && distanceToCenter-catadioptricDistanceToCenter<1.0) {
-			insideBokeh = (distanceToCenter-catadioptricDistanceToCenter);
+		else if (this->data->catadioptric != 0.0f && distanceToCenter - catadioptricDistanceToCenter < 1.0f) {
+			insideBokeh = (distanceToCenter - catadioptricDistanceToCenter);
 		}
 		else {
-			insideBokeh = 1.0;
+			insideBokeh = 1.0f;
 		}
 	}
 	return insideBokeh;
@@ -90,11 +90,11 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
 void BokehImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
 {
 	float shift = this->data->lensshift;
-	float shift2 = shift/2.0f;
+	float shift2 = shift / 2.0f;
 	float distance = this->circularDistance;
 	float insideBokehMax = isInsideBokeh(distance, x, y);
-	float insideBokehMed = isInsideBokeh(distance-fabs(shift2*distance), x, y);
-	float insideBokehMin = isInsideBokeh(distance-fabs(shift*distance), x, y);
+	float insideBokehMed = isInsideBokeh(distance - fabsf(shift2 * distance), x, y);
+	float insideBokehMin = isInsideBokeh(distance - fabsf(shift * distance), x, y);
 	if (shift<0) {
 		color[0] = insideBokehMax;
 		color[1] = insideBokehMed;
diff --git a/source/blender/compositor/operations/COM_BoxMaskOperation.cpp b/source/blender/compositor/operations/COM_BoxMaskOperation.cpp
index 0244be4cad3..ae83115ff69 100644
--- a/source/blender/compositor/operations/COM_BoxMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_BoxMaskOperation.cpp
@@ -38,7 +38,7 @@ void BoxMaskOperation::initExecution()
 {
 	this->inputMask = this->getInputSocketReader(0);
 	this->inputValue = this->getInputSocketReader(1);
-	const double rad = DEG2RAD(this->data->rotation);
+	const double rad = DEG2RAD((double)this->data->rotation);
 	this->cosine = cos(rad);
 	this->sine = sin(rad);
 	this->aspectRatio = ((float)this->getWidth())/this->getHeight();
@@ -60,12 +60,12 @@ void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler
 	this->inputMask->read(inputMask, x, y, sampler, inputBuffers);
 	this->inputValue->read(inputValue, x, y, sampler, inputBuffers);
 	
-	float halfHeight = (this->data->height)/2.0f;
-	float halfWidth = this->data->width/2.0f;
-	bool inside = rx > this->data->x-halfWidth
-			&& rx < this->data->x+halfWidth
-			&& ry > this->data->y-halfHeight
-			&& ry < this->data->y+halfHeight;
+	float halfHeight = this->data->height / 2.0f;
+	float halfWidth = this->data->width / 2.0f;
+	bool inside = (rx > this->data->x - halfWidth &&
+	               rx < this->data->x + halfWidth &&
+	               ry > this->data->y - halfHeight &&
+	               ry < this->data->y + halfHeight);
 	
 	switch (this->maskType) {
 		case CMP_NODE_MASKTYPE_ADD:
diff --git a/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp b/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
index 9b7f87e38bc..f949b0a55fa 100644
--- a/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
+++ b/source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
@@ -46,7 +46,8 @@ void ChangeHSVOperation::executePixel(float *outputValue, float x, float y, Pixe
 	inputOperation->read(inputColor1, x, y, sampler, inputBuffers);
 	
 	outputValue[0] = inputColor1[0] + (this->hue - 0.5f);
-	if (outputValue[0]>1.0f) outputValue[0]-=1.0; else if (outputValue[0]<0.0) outputValue[0]+= 1.0;
+	if      (outputValue[0] > 1.0f)  outputValue[0] -= 1.0f;
+	else if (outputValue[0] < 0.0f)  outputValue[0] += 1.0f;
 	outputValue[1] = inputColor1[1] * this->saturation;
 	outputValue[2] = inputColor1[2] * this->value;
 	outputValue[3] = inputColor1[3];
diff --git a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
index cc535cd95df..6fe6bde7c09 100644
--- a/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
@@ -28,7 +28,7 @@ inline float colorbalance_cdl(float in, float offset, float power, float slope)
 	float x = in * slope + offset;
 
 	/* prevent NaN */
-	CLAMP(x, 0.0, 1.0);
+	CLAMP(x, 0.0f, 1.0f);
 
 	return powf(x, power);
 }
diff --git a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
index af28b776892..82a71f6a7a8 100644
--- a/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
@@ -62,21 +62,21 @@ void ColorCorrectionOperation::executePixel(float *output, float x, float y, Pix
 	float levelShadows = 0.0;
 	float levelMidtones = 0.0;
 	float levelHighlights = 0.0;
-#define MARGIN 0.10
-#define MARGIN_DIV (0.5/MARGIN)
-	if (level < this->data->startmidtones-MARGIN) {
+#define MARGIN 0.10f
+#define MARGIN_DIV (0.5f / MARGIN)
+	if (level < this->data->startmidtones - MARGIN) {
 		levelShadows = 1.0f;
 	}
-	else if (level < this->data->startmidtones+MARGIN) {
-		levelMidtones = ((level-this->data->startmidtones)*MARGIN_DIV)+0.5;
-		levelShadows = 1.0 - levelMidtones;
+	else if (level < this->data->startmidtones + MARGIN) {
+		levelMidtones = ((level - this->data->startmidtones) * MARGIN_DIV) + 0.5f;
+		levelShadows = 1.0f - levelMidtones;
 	}
-	else if (level < this->data->endmidtones-MARGIN) {
+	else if (level < this->data->endmidtones - MARGIN) {
 		levelMidtones = 1.0f;
 	}
-	else if (level < this->data->endmidtones+MARGIN) {
-		levelHighlights = ((level-this->data->endmidtones)*MARGIN_DIV)+0.5;
-		levelMidtones = 1.0 - levelHighlights;
+	else if (level < this->data->endmidtones + MARGIN) {
+		levelHighlights = ((level - this->data->endmidtones) * MARGIN_DIV) + 0.5f;
+		levelMidtones = 1.0f - levelHighlights;
 	}
 	else {
 		levelHighlights = 1.0f;
@@ -93,15 +93,15 @@ void ColorCorrectionOperation::executePixel(float *output, float x, float y, Pix
 	g = inputImageColor[1];
 	b = inputImageColor[2];
 	
-	float invgamma = 1.0f/gamma;
-	float luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+	float invgamma = 1.0f / gamma;
+	float luma = 0.2126f * r + 0.7152f * g + 0.0722f * b;
 	r = (luma + saturation * (r - luma));
 	g = (luma + saturation * (g - luma));
 	b = (luma + saturation * (b - luma));
 	
-	r = 0.5+((r-0.5)*contrast);
-	g = 0.5+((g-0.5)*contrast);
-	b = 0.5+((b-0.5)*contrast);
+	r = 0.5f + ((r - 0.5f) * contrast);
+	g = 0.5f + ((g - 0.5f) * contrast);
+	b = 0.5f + ((b - 0.5f) * contrast);
 	
 	r = powf(r*gain+lift, invgamma);
 	g = powf(g*gain+lift, invgamma);
diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.cpp b/source/blender/compositor/operations/COM_ColorCurveOperation.cpp
index 8aee54013b1..a38012271f1 100644
--- a/source/blender/compositor/operations/COM_ColorCurveOperation.cpp
+++ b/source/blender/compositor/operations/COM_ColorCurveOperation.cpp
@@ -28,6 +28,7 @@ extern "C" {
 	#include "BKE_colortools.h"
 #ifdef __cplusplus
 }
+#include "MEM_guardedalloc.h"
 #endif
 
 ColorCurveOperation::ColorCurveOperation(): CurveBaseOperation()
@@ -59,6 +60,9 @@ void ColorCurveOperation::initExecution()
 
 void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
 {
+	CurveMapping* cumap = this->curveMapping;
+	CurveMapping* workingCopy = (CurveMapping*)MEM_dupallocN(cumap);
+	
 	float black[4];
 	float white[4];
 	float fac[4];
@@ -67,26 +71,27 @@ void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSamp
 	this->inputBlackProgram->read(black, x, y, sampler, inputBuffers);
 	this->inputWhiteProgram->read(white, x, y, sampler, inputBuffers);
 
-	curvemapping_set_black_white(this->curveMapping, black, white);
+	curvemapping_set_black_white(workingCopy, black, white);
 
 	this->inputFacProgram->read(fac, x, y, sampler, inputBuffers);
 	this->inputImageProgram->read(image, x, y, sampler, inputBuffers);
 
-	if (fac[0] >= 1.0)
-		curvemapping_evaluate_premulRGBF(this->curveMapping, color, image);
-	else if (*fac<=0.0) {
+	if (*fac >= 1.0f)
+		curvemapping_evaluate_premulRGBF(workingCopy, color, image);
+	else if (*fac <= 0.0f) {
 		color[0] = image[0];
 		color[1] = image[1];
 		color[2] = image[2];
 	}
 	else {
-		float col[4], mfac = 1.0f-*fac;
-		curvemapping_evaluate_premulRGBF(this->curveMapping, col, image);
-		color[0] = mfac*image[0] + *fac*col[0];
-		color[1] = mfac*image[1] + *fac*col[1];
-		color[2] = mfac*image[2] + *fac*col[2];
+		float col[4], mfac = 1.0f - *fac;
+		curvemapping_evaluate_premulRGBF(workingCopy, col, image);
+		color[0] = mfac * image[0] + *fac * col[0];
+		color[1] = mfac * image[1] + *fac * col[1];
+		color[2] = mfac * image[2] + *fac * col[2];
 	}
 	color[3] = image[3];
+	MEM_freeN(workingCopy);
 }
 
 void ColorCurveOperation::deinitExecution()
@@ -97,3 +102,61 @@ void ColorCurveOperation::deinitExecution()
 	this->inputWhiteProgram = NULL;
 	curvemapping_premultiply(this->curveMapping, 1);
 }
+
+
+// Constant level curve mapping
+
+ConstantLevelColorCurveOperation::ConstantLevelColorCurveOperation(): CurveBaseOperation()
+{
+	this->addInputSocket(COM_DT_VALUE);
+	this->addInputSocket(COM_DT_COLOR);
+	this->addOutputSocket(COM_DT_COLOR);
+
+	this->inputFacProgram = NULL;
+	this->inputImageProgram = NULL;
+
+	this->setResolutionInputSocketIndex(1);
+}
+void ConstantLevelColorCurveOperation::initExecution()
+{
+	CurveBaseOperation::initExecution();
+	this->inputFacProgram = this->getInputSocketReader(0);
+	this->inputImageProgram = this->getInputSocketReader(1);
+
+	curvemapping_premultiply(this->curveMapping, 0);
+
+	curvemapping_set_black_white(this->curveMapping, this->black, this->white);
+}
+
+void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+{
+	float fac[4];
+	float image[4];
+
+
+	this->inputFacProgram->read(fac, x, y, sampler, inputBuffers);
+	this->inputImageProgram->read(image, x, y, sampler, inputBuffers);
+
+	if (*fac >= 1.0f)
+		curvemapping_evaluate_premulRGBF(this->curveMapping, color, image);
+	else if (*fac <= 0.0f) {
+		color[0] = image[0];
+		color[1] = image[1];
+		color[2] = image[2];
+	}
+	else {
+		float col[4], mfac = 1.0f - *fac;
+		curvemapping_evaluate_premulRGBF(this->curveMapping, col, image);
+		color[0] = mfac * image[0] + *fac * col[0];
+		color[1] = mfac * image[1] + *fac * col[1];
+		color[2] = mfac * image[2] + *fac * col[2];
+	}
+	color[3] = image[3];
+}
+
+void ConstantLevelColorCurveOperation::deinitExecution()
+{
+	this->inputFacProgram = NULL;
+	this->inputImageProgram = NULL;
+	curvemapping_premultiply(this->curveMapping, 1);
+}
diff --git a/source/blender/compositor/operations/COM_ColorCurveOperation.h b/source/blender/compositor/operations/COM_ColorCurveOperation.h
index 15f9fd25e81..6ce5befb14a 100644
--- a/source/blender/compositor/operations/COM_ColorCurveOperation.h
+++ b/source/blender/compositor/operations/COM_ColorCurveOperation.h
@@ -53,4 +53,37 @@ public:
 	  */
 	void deinitExecution();
 };
+
+class ConstantLevelColorCurveOperation : public CurveBaseOperation {
+private:
+	/**
+	  * Cached reference to the inputProgram
+	  */
+	SocketReader * inputFacProgram;
+	SocketReader * inputImageProgram;
+	float black[3];
+	float white[3];
+	
+public:
+	ConstantLevelColorCurveOperation();
+	
+	/**
+	  * the inner loop of this program
+	  */
+	void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]);
+	
+	/**
+	  * Initialize the execution
+	  */
+	void initExecution();
+	
+	/**
+	  * Deinitialize the execution
+	  */
+	void deinitExecution();
+	
+	void setBlackLevel(float black[3]) {this->black[0] =black[0];this->black[1] =black[1];this->black[2] =black[2]; }
+	void setWhiteLevel(float white[3]) {this->white[0] =white[0];this->white[1] =white[1];this->white[2] =white[2]; }
+};
+
 #endif
diff --git a/source/blender/compositor/operations/COM_CompositorOperation.h b/source/blender/compositor/operations/COM_CompositorOperation.h
index 41d43f896bb..13cb4f28324 100644
--- a/source/blender/compositor/operations/COM_CompositorOperation.h
+++ b/source/blender/compositor/operations/COM_CompositorOperation.h
@@ -63,7 +63,7 @@ public:
 	bool isOutputOperation(bool rendering) const {return true;}
 	void initExecution();
 	void deinitExecution();
-	const int getRenderPriority() const {return 7;}
+	const CompositorPriority getRenderPriority() const {return COM_PRIORITY_MEDIUM;}
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
index 628daa7c775..0b1ac1b2127 100644
--- a/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
+++ b/source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
@@ -57,16 +57,16 @@ void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y
 	this->inputImage1Program->read(inColor1, x, y, sampler, inputBuffers);
 	this->inputImage2Program->read(inColor2, x, y, sampler, inputBuffers);
 
-	difference = (fabs(inColor2[0] - inColor1[0]) +
-	              fabs(inColor2[1] - inColor1[1]) +
-	              fabs(inColor2[2] - inColor1[2]));
+	difference = (fabsf(inColor2[0] - inColor1[0]) +
+	              fabsf(inColor2[1] - inColor1[1]) +
+	              fabsf(inColor2[2] - inColor1[2]));
 
-	/*average together the distances*/
-	difference=difference/3.0;
+	/* average together the distances */
+	difference = difference / 3.0f;
 
 	/*make 100% transparent*/
 	if (difference < tolerence) {
-		outputValue[0]=0.0;
+		outputValue[0] = 0.0f;
 	}
 	/*in the falloff region, make partially transparent */
 	else if (difference < falloff+tolerence) {
diff --git a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
index 30a09a45ade..43cba09d16f 100644
--- a/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
@@ -51,17 +51,17 @@ void DirectionalBlurOperation::initExecution()
 	const float height = getHeight();
 
 	const float a = angle;
-	const float itsc = 1.f / pow(2.f, (float)iterations);
+	const float itsc = 1.0f / powf(2.0f, (float)iterations);
 	float D;
 
 	D = distance * sqrtf(width*width + height*height);
 	center_x_pix = center_x * width;
 	center_y_pix = center_y * height;
 
-	tx=  itsc * D * cos(a);
-	ty= -itsc * D * sin(a);
-	sc=  itsc * zoom;
-	rot = itsc * spin;
+	tx  =  itsc * D * cosf(a);
+	ty  = -itsc * D * sinf(a);
+	sc  =  itsc * zoom;
+	rot =  itsc * spin;
 
 }
 
diff --git a/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp b/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
index 85a629f7365..650c57dd8dc 100644
--- a/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
@@ -38,7 +38,7 @@ void EllipseMaskOperation::initExecution()
 {
 	this->inputMask = this->getInputSocketReader(0);
 	this->inputValue = this->getInputSocketReader(1);
-	const double rad = DEG2RAD(this->data->rotation);
+	const double rad = DEG2RAD((double)this->data->rotation);
 	this->cosine = cos(rad);
 	this->sine = sin(rad);
 	this->aspectRatio = ((float)this->getWidth())/this->getHeight();
diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
index ad8f3b12387..ad58631f2c1 100644
--- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
@@ -26,13 +26,12 @@
 
 FastGaussianBlurOperation::FastGaussianBlurOperation(): BlurBaseOperation()
 {
-	this->iirgaus = false;
+	this->iirgaus = NULL;
 }
 
 void FastGaussianBlurOperation::executePixel(float *color,int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
 	MemoryBuffer *newData = (MemoryBuffer*)data;
-	
 	newData->read(color, x, y);	
 }
 
@@ -51,10 +50,7 @@ bool FastGaussianBlurOperation::determineDependingAreaOfInterest(rcti *input, Re
 	}
 	else {
 		if (this->iirgaus) {
-			newInput.xmax = input->xmax + (sx);
-			newInput.xmin = input->xmin - (sx);
-			newInput.ymax = input->ymax + (sy);
-			newInput.ymin = input->ymin - (sy);
+			return false;
 		}
 		else {
 			newInput.xmin = 0;
@@ -66,38 +62,51 @@ bool FastGaussianBlurOperation::determineDependingAreaOfInterest(rcti *input, Re
 	}
 }
 
-void *FastGaussianBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void FastGaussianBlurOperation::initExecution()
 {
-	MemoryBuffer *newBuf = (MemoryBuffer*)this->inputProgram->initializeTileData(rect, memoryBuffers);
-	MemoryBuffer *copy = newBuf->duplicate();
-	updateSize(memoryBuffers);
-	
-	int c;
-	sx = data->sizex * this->size/2.0f;
-	sy = data->sizey * this->size/2.0f;	
-	this->iirgaus = true;
-	
-	if ((sx == sy) && (sx > 0.f)) {
-		for (c=0; c<COM_NUMBER_OF_CHANNELS; ++c)
-			IIR_gauss(copy, sx, c, 3);
+	BlurBaseOperation::initExecution();
+	BlurBaseOperation::initMutex();
+}
+
+void FastGaussianBlurOperation::deinitExecution() 
+{
+	if (this->iirgaus) {
+		delete this->iirgaus;
+		this->iirgaus = NULL;
 	}
-	else {
-		if (sx > 0.f) {
+	BlurBaseOperation::deinitMutex();	
+}
+
+void *FastGaussianBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+{
+	BLI_mutex_lock(this->getMutex());
+	if (!iirgaus) {
+		MemoryBuffer *newBuf = (MemoryBuffer*)this->inputProgram->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *copy = newBuf->duplicate();
+		updateSize(memoryBuffers);
+		
+		int c;
+		sx = data->sizex * this->size/2.0f;
+		sy = data->sizey * this->size/2.0f;	
+		
+		if ((sx == sy) && (sx > 0.f)) {
 			for (c=0; c<COM_NUMBER_OF_CHANNELS; ++c)
-				IIR_gauss(copy, sx, c, 1);
+				IIR_gauss(copy, sx, c, 3);
 		}
-		if (sy > 0.f) {
-			for (c=0; c<COM_NUMBER_OF_CHANNELS; ++c)
-				IIR_gauss(copy, sy, c, 2);
+		else {
+			if (sx > 0.f) {
+				for (c=0; c<COM_NUMBER_OF_CHANNELS; ++c)
+					IIR_gauss(copy, sx, c, 1);
+			}
+			if (sy > 0.f) {
+				for (c=0; c<COM_NUMBER_OF_CHANNELS; ++c)
+					IIR_gauss(copy, sy, c, 2);
+			}
 		}
+		this->iirgaus = copy;
 	}
-	return copy;
-}
-
-void FastGaussianBlurOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
-{
-	MemoryBuffer *newData = (MemoryBuffer*)data;
-	delete newData;
+	BLI_mutex_unlock(this->getMutex());
+	return iirgaus;
 }
 
 void FastGaussianBlurOperation::IIR_gauss(MemoryBuffer *src, float sigma, int chan, int xy)
diff --git a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
index 6c3e373472b..1f71fe7f9ed 100644
--- a/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
+++ b/source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
@@ -30,7 +30,7 @@ class FastGaussianBlurOperation: public BlurBaseOperation {
 private:
 	float sx;
 	float sy;
-	bool iirgaus;
+	MemoryBuffer* iirgaus;
 public:
 	FastGaussianBlurOperation();
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
@@ -38,7 +38,8 @@ public:
 	
 	static void IIR_gauss(MemoryBuffer *src, float sigma, int channel, int xy);
 	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-	void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+	void deinitExecution();
+	void initExecution();
 	
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_FogGlowImageOperation.cpp b/source/blender/compositor/operations/COM_FogGlowImageOperation.cpp
index 600bfde64d9..05a758aca7f 100644
--- a/source/blender/compositor/operations/COM_FogGlowImageOperation.cpp
+++ b/source/blender/compositor/operations/COM_FogGlowImageOperation.cpp
@@ -37,7 +37,7 @@ void FogGlowImageOperation::executePixel(float *color, float x, float y, PixelSa
 	u = 2.f*(x / (float)512) - 1.f;
 	r = (u*u + v*v)*256;
 	d = -sqrtf(sqrtf(sqrtf(r)));
-	w = (0.5f + 0.5f*cos((double)u*M_PI))*(0.5f + 0.5f*cos((double)v*M_PI));
+	w = (0.5f + 0.5f * cosf(u * (float)M_PI)) * (0.5f + 0.5f * cosf(v * (float)M_PI));
 	color[0] = expf(d*cs_r) * w;
 	color[1] = expf(d*cs_g) * w;
 	color[2] = expf(d*cs_b) * w;
diff --git a/source/blender/compositor/operations/COM_GammaOperation.cpp b/source/blender/compositor/operations/COM_GammaOperation.cpp
index f0887d4adee..989ffd5dfba 100644
--- a/source/blender/compositor/operations/COM_GammaOperation.cpp
+++ b/source/blender/compositor/operations/COM_GammaOperation.cpp
@@ -46,9 +46,9 @@ void GammaOperation::executePixel(float *color, float x, float y, PixelSampler s
 	this->inputGammaProgram->read(inputGamma, x, y, sampler, inputBuffers);
 	const float gamma = inputGamma[0];
 	/* check for negative to avoid nan's */
-	color[0] = inputValue[0]>0.0f?pow(inputValue[0], gamma):inputValue[0];
-	color[1] = inputValue[1]>0.0f?pow(inputValue[1], gamma):inputValue[1];
-	color[2] = inputValue[2]>0.0f?pow(inputValue[2], gamma):inputValue[2];
+	color[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0];
+	color[1] = inputValue[1] > 0.0f ? powf(inputValue[1], gamma) : inputValue[1];
+	color[2] = inputValue[2] > 0.0f ? powf(inputValue[2], gamma) : inputValue[2];
 	
 	color[3] = inputValue[3];
 }
diff --git a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
index b5d175729f3..e522d334d8b 100644
--- a/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
@@ -43,6 +43,8 @@ void *GaussianBokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **
 
 void GaussianBokehBlurOperation::initExecution()
 {
+	BlurBaseOperation::initExecution();
+
 	if (this->sizeavailable) {
 		updateGauss(NULL);
 	}
@@ -145,11 +147,11 @@ void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, Memory
 			bufferindex +=offsetadd;
 		}
 	}
-	float divider = 1.0/overallmultiplyer;
-	color[0] = tempColor[0]*divider;
-	color[1] = tempColor[1]*divider;
-	color[2] = tempColor[2]*divider;
-	color[3] = tempColor[3]*divider;
+	float divider = 1.0f / overallmultiplyer;
+	color[0] = tempColor[0] * divider;
+	color[1] = tempColor[1] * divider;
+	color[2] = tempColor[2] * divider;
+	color[3] = tempColor[3] * divider;
 }
 
 void GaussianBokehBlurOperation::deinitExecution()
diff --git a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
index 121bbbd45a0..2eb51b4577f 100644
--- a/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
@@ -45,6 +45,8 @@ void *GaussianXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memo
 
 void GaussianXBlurOperation::initExecution()
 {
+	BlurBaseOperation::initExecution();
+
 	if (this->sizeavailable) {
 		float rad = size*this->data->sizex;
 		if (rad<1)
@@ -75,7 +77,7 @@ void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuff
 	tempColor[1] = 0;
 	tempColor[2] = 0;
 	tempColor[3] = 0;
-	float overallmultiplyer = 0;
+	float overallmultiplyer = 0.0f;
 	MemoryBuffer *inputBuffer = (MemoryBuffer*)data;
 	float *buffer = inputBuffer->getBuffer();
 	int bufferwidth = inputBuffer->getWidth();
@@ -104,11 +106,11 @@ void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuff
 		overallmultiplyer += multiplyer;
 		bufferindex +=offsetadd;
 	}
-	float divider = 1.0/overallmultiplyer;
-	color[0] = tempColor[0]*divider;
-	color[1] = tempColor[1]*divider;
-	color[2] = tempColor[2]*divider;
-	color[3] = tempColor[3]*divider;
+	float divider = 1.0f / overallmultiplyer;
+	color[0] = tempColor[0] * divider;
+	color[1] = tempColor[1] * divider;
+	color[2] = tempColor[2] * divider;
+	color[3] = tempColor[3] * divider;
 }
 
 void GaussianXBlurOperation::deinitExecution()
diff --git a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
index cab3e3d6094..28e8e548530 100644
--- a/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
@@ -101,11 +101,11 @@ void GaussianYBlurOperation::executePixel(float *color, int x, int y, MemoryBuff
 		tempColor[3] += multiplyer * buffer[bufferindex+3];
 		overallmultiplyer += multiplyer;
 	}
-	float divider = 1.0/overallmultiplyer;
-	color[0] = tempColor[0]*divider;
-	color[1] = tempColor[1]*divider;
-	color[2] = tempColor[2]*divider;
-	color[3] = tempColor[3]*divider;
+	float divider = 1.0f / overallmultiplyer;
+	color[0] = tempColor[0] * divider;
+	color[1] = tempColor[1] * divider;
+	color[2] = tempColor[2] * divider;
+	color[3] = tempColor[3] * divider;
 }
 
 void GaussianYBlurOperation::deinitExecution()
diff --git a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
index 2970c396493..2afcc2e5cc7 100644
--- a/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
+++ b/source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
@@ -63,8 +63,8 @@ void HueSaturationValueCorrectOperation::executePixel(float *output, float x, fl
 	f = curvemapping_evaluateF(this->curveMapping, 2, hsv[0]);
 	hsv[2] *= (f * 2.f);
 
-	hsv[0] = hsv[0] - floor(hsv[0]);  /* mod 1.0 */
-	CLAMP(hsv[1], 0.f, 1.f);
+	hsv[0] = hsv[0] - floorf(hsv[0]);  /* mod 1.0 */
+	CLAMP(hsv[1], 0.0f, 1.0f);
 
 	output[0] = hsv[0];
 	output[1] = hsv[1];
diff --git a/source/blender/compositor/operations/COM_ImageOperation.cpp b/source/blender/compositor/operations/COM_ImageOperation.cpp
index 020dfdbdc14..04cd91d3c3a 100644
--- a/source/blender/compositor/operations/COM_ImageOperation.cpp
+++ b/source/blender/compositor/operations/COM_ImageOperation.cpp
@@ -99,8 +99,8 @@ void BaseImageOperation::determineResolution(unsigned int resolution[], unsigned
 {
 	ImBuf *stackbuf = getImBuf();
 
-        resolution[0] = 0;
-        resolution[1] = 0;
+	resolution[0] = 0;
+	resolution[1] = 0;
 
 	if (stackbuf) {
 		resolution[0] = stackbuf->x;
diff --git a/source/blender/compositor/operations/COM_MapUVOperation.cpp b/source/blender/compositor/operations/COM_MapUVOperation.cpp
index 7b393cc04a8..035f5584065 100644
--- a/source/blender/compositor/operations/COM_MapUVOperation.cpp
+++ b/source/blender/compositor/operations/COM_MapUVOperation.cpp
@@ -61,16 +61,16 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
 	/* adaptive sampling, red (U) channel */
 	this->inputUVProgram->read(uv_a, x-1, y, COM_PS_NEAREST, inputBuffers);
 	this->inputUVProgram->read(uv_b, x+1, y, COM_PS_NEAREST, inputBuffers);
-	uv_l = uv_a[2]!=0.f? fabs(inputUV[0] - uv_a[0]) : 0.f;
-	uv_r = uv_b[2]!=0.f? fabs(inputUV[0] - uv_b[0]) : 0.f;
+	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->inputUVProgram->read(uv_a, x, y-1, COM_PS_NEAREST, inputBuffers);
 	this->inputUVProgram->read(uv_b, x, y+1, COM_PS_NEAREST, inputBuffers);
-	uv_u = uv_a[2]!=0.f? fabs(inputUV[1] - uv_a[1]) : 0.f;
-	uv_d = uv_b[2]!=0.f? fabs(inputUV[1] - uv_b[1]) : 0.f;
+	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);
 
diff --git a/source/blender/compositor/operations/COM_MaskOperation.cpp b/source/blender/compositor/operations/COM_MaskOperation.cpp
new file mode 100644
index 00000000000..a7c1de323f1
--- /dev/null
+++ b/source/blender/compositor/operations/COM_MaskOperation.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor:
+ *		Jeroen Bakker
+ *		Monique Dewanchand
+ *		Sergey Sharybin
+ */
+
+#include "COM_MaskOperation.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_listbase.h"
+#include "BLI_math.h"
+
+#include "DNA_scene_types.h"
+
+extern "C" {
+	#include "BKE_mask.h"
+}
+
+MaskOperation::MaskOperation(): NodeOperation()
+{
+	this->addInputSocket(COM_DT_COLOR);
+	this->addOutputSocket(COM_DT_COLOR);
+	this->mask = NULL;
+	this->maskWidth = 0;
+	this->maskHeight = 0;
+	this->framenumber = 0;
+	this->rasterizedMask = NULL;
+	setComplex(true);
+}
+
+void MaskOperation::initExecution()
+{
+	initMutex();
+	this->rasterizedMask = NULL;
+}
+
+void MaskOperation::deinitExecution()
+{
+	if (this->rasterizedMask) {
+		MEM_freeN(rasterizedMask);
+		this->rasterizedMask = NULL;
+	}
+}
+
+void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+{
+	if (this->rasterizedMask)
+		return this->rasterizedMask;
+
+	if (!this->mask)
+		return NULL;
+
+	BLI_mutex_lock(getMutex());
+	if (this->rasterizedMask == NULL) {
+		int width = this->getWidth();
+		int height = this->getHeight();
+		float *buffer;
+
+		buffer = (float *)MEM_callocN(sizeof(float) * width * height, "rasterized mask");
+		BKE_mask_rasterize(mask, width, height, buffer, TRUE, TRUE);
+
+		this->rasterizedMask = buffer;
+	}
+	BLI_mutex_unlock(getMutex());
+
+	return this->rasterizedMask;
+}
+
+void MaskOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
+{
+	if (maskWidth == 0 || maskHeight == 0) {
+		NodeOperation::determineResolution(resolution, preferredResolution);
+	}
+	else {
+		unsigned int nr[2];
+
+		nr[0] = maskWidth;
+		nr[1] = maskHeight;
+
+		NodeOperation::determineResolution(resolution, nr);
+
+		resolution[0] = maskWidth;
+		resolution[1] = maskHeight;
+	}
+}
+
+void MaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+{
+	if (!data) {
+		color[0] = 0;
+		color[1] = 0;
+		color[2] = 0;
+		color[3] = 1.0f;
+	}
+	else {
+		float *buffer = (float*) data;
+		int index = (y * this->getWidth() + x);
+
+		color[0] = buffer[index];
+		color[1] = buffer[index];
+		color[2] = buffer[index];
+		color[3] = 1.0f;
+	}
+}
+
+
diff --git a/source/blender/compositor/operations/COM_MaskOperation.h b/source/blender/compositor/operations/COM_MaskOperation.h
new file mode 100644
index 00000000000..9f2c7f53f56
--- /dev/null
+++ b/source/blender/compositor/operations/COM_MaskOperation.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012, Blender Foundation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor:
+ *		Jeroen Bakker
+ *		Monique Dewanchand
+ *		Sergey Sharybin
+ */
+
+
+#ifndef _COM_MaskOperation_h
+#define _COM_MaskOperation_h
+
+#include "COM_NodeOperation.h"
+#include "DNA_scene_types.h"
+#include "DNA_mask_types.h"
+#include "BLI_listbase.h"
+#include "IMB_imbuf_types.h"
+
+/**
+  * Class with implementation of mask rasterization
+  */
+class MaskOperation : public NodeOperation {
+protected:
+	Mask *mask;
+	int maskWidth;
+	int maskHeight;
+	int framenumber;
+	float *rasterizedMask;
+
+	/**
+	  * Determine the output resolution. The resolution is retrieved from the Renderer
+	  */
+	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
+
+public:
+	MaskOperation();
+
+	void initExecution();
+	void deinitExecution();
+
+	void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+
+	void setMask(Mask *mask) {this->mask = mask;}
+	void setMaskWidth(int width) {this->maskWidth = width;}
+	void setMaskHeight(int height) {this->maskHeight = height;}
+	void setFramenumber(int framenumber) {this->framenumber = framenumber;}
+
+	void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+};
+
+#endif
diff --git a/source/blender/compositor/operations/COM_MathBaseOperation.cpp b/source/blender/compositor/operations/COM_MathBaseOperation.cpp
index 2ea5f85253b..b943ec88fde 100644
--- a/source/blender/compositor/operations/COM_MathBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_MathBaseOperation.cpp
@@ -196,8 +196,8 @@ void MathPowerOperation::executePixel(float *outputValue, float x, float y, Pixe
 	else {
 		float y_mod_1 = fmod(inputValue2[0], 1);
 		/* if input value is not nearly an integer, fall back to zero, nicer than straight rounding */
-		if (y_mod_1 > 0.999 || y_mod_1 < 0.001) {
-			outputValue[0] = pow(inputValue1[0], (float)floor(inputValue2[0] + 0.5));
+		if (y_mod_1 > 0.999f || y_mod_1 < 0.001f) {
+			outputValue[0] = pow(inputValue1[0], floorf(inputValue2[0] + 0.5f));
 		}
 		else {
 			outputValue[0] = 0.0;
diff --git a/source/blender/compositor/operations/COM_OpenCLKernels.cl b/source/blender/compositor/operations/COM_OpenCLKernels.cl
index 40932e54bc7..aeccfcab8b5 100644
--- a/source/blender/compositor/operations/COM_OpenCLKernels.cl
+++ b/source/blender/compositor/operations/COM_OpenCLKernels.cl
@@ -1,10 +1,52 @@
 /// This file contains all opencl kernels for node-operation implementations 
 
-__kernel void testKernel(__global __write_only image2d_t output)
+// Global SAMPLERS
+const sampler_t SAMPLER_NEAREST      = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__constant const int2 zero = {0,0};
+
+// KERNEL --- BOKEH BLUR ---
+__kernel void bokehBlurKernel(__global __read_only image2d_t boundingBox, __global __read_only image2d_t inputImage, 
+                              __global __read_only image2d_t bokehImage, __global __write_only image2d_t output, 
+                              int2 offsetInput, int2 offsetOutput, int radius, int step, int2 dimension, int2 offset) 
 {
-	int x = get_global_id(0);
-	int y = get_global_id(1);
-	int2 coords = {x, y}; 
-	float4 color = {0.0f, 1.0f, 0.0f, 1.0f};
+	int2 coords = {get_global_id(0), get_global_id(1)}; 
+	coords += offset;
+	float tempBoundingBox;
+	float4 color = {0.0f,0.0f,0.0f,0.0f};
+	float4 multiplyer = {0.0f,0.0f,0.0f,0.0f};
+	float4 bokeh;
+	const float radius2 = radius*2.0f;
+	const int2 realCoordinate = coords + offsetOutput;
+
+	tempBoundingBox = read_imagef(boundingBox, SAMPLER_NEAREST, coords).s0;
+
+	if (tempBoundingBox > 0.0f) {
+		const int2 bokehImageDim = get_image_dim(bokehImage);
+		const int2 bokehImageCenter = bokehImageDim/2;
+		const int2 minXY = max(realCoordinate - radius, zero);
+		const int2 maxXY = min(realCoordinate + radius, dimension);
+		int nx, ny;
+		
+		float2 uv;
+		int2 inputXy;
+		
+		for (ny = minXY.y, inputXy.y = ny - offsetInput.y ; ny < maxXY.y ; ny +=step, inputXy.y+=step) {
+			uv.y = ((realCoordinate.y-ny)/radius2)*bokehImageDim.y+bokehImageCenter.y;
+			
+			for (nx = minXY.x, inputXy.x = nx - offsetInput.x; nx < maxXY.x ; nx +=step, inputXy.x+=step) {
+				uv.x = ((realCoordinate.x-nx)/radius2)*bokehImageDim.x+bokehImageCenter.x;
+				bokeh = read_imagef(bokehImage, SAMPLER_NEAREST, uv);
+				color += bokeh * read_imagef(inputImage, SAMPLER_NEAREST, inputXy);
+				multiplyer += bokeh;
+			}
+		}
+		color /= multiplyer;
+		
+	} else {
+		int2 imageCoordinates = realCoordinate - offsetInput;
+		color = read_imagef(inputImage, SAMPLER_NEAREST, imageCoordinates);
+	}
+	
 	write_imagef(output, coords, color);
 }
diff --git a/source/blender/compositor/operations/COM_OpenCLKernels.cl.cpp b/source/blender/compositor/operations/COM_OpenCLKernels.cl.cpp
deleted file mode 100644
index 1024d460044..00000000000
--- a/source/blender/compositor/operations/COM_OpenCLKernels.cl.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/// @todo: this source needs to be generated from COM_OpenCLKernels.cl.
-/// not implemented yet. new data to h
-
-const char *sourcecode = "/// This file contains all opencl kernels for node-operation implementations \n" \
-"\n" \
-"__kernel void testKernel(__global __write_only image2d_t output)\n" \
-"{\n" \
-"	int x = get_global_id(0);\n" \
-"	int y = get_global_id(1);\n" \
-"	int2 coords = {x, y}; \n" \
-"	float4 color = {0.0f, 1.0f, 0.0f, 1.0f};\n" \
-"	write_imagef(output, coords, color);\n" \
-"}\n" \
-"\0\n";
-
diff --git a/source/blender/compositor/operations/COM_OpenCLKernels.cl.h b/source/blender/compositor/operations/COM_OpenCLKernels.cl.h
new file mode 100644
index 00000000000..3cf33c75272
--- /dev/null
+++ b/source/blender/compositor/operations/COM_OpenCLKernels.cl.h
@@ -0,0 +1,55 @@
+/* clkernelstoh output of file <COM_OpenCLKernels_cl> */
+
+const char * clkernelstoh_COM_OpenCLKernels_cl = "/// This file contains all opencl kernels for node-operation implementations\n" \
+"\n" \
+"// Global SAMPLERS\n" \
+"const sampler_t SAMPLER_NEAREST      = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;\n" \
+"\n" \
+"__constant const int2 zero = {0,0};\n" \
+"\n" \
+"// KERNEL --- BOKEH BLUR ---\n" \
+"__kernel void bokehBlurKernel(__global __read_only image2d_t boundingBox, __global __read_only image2d_t inputImage,\n" \
+"                              __global __read_only image2d_t bokehImage, __global __write_only image2d_t output,\n" \
+"                              int2 offsetInput, int2 offsetOutput, int radius, int step, int2 dimension, int2 offset)\n" \
+"{\n" \
+"	int2 coords = {get_global_id(0), get_global_id(1)};\n" \
+"	coords += offset;\n" \
+"	float tempBoundingBox;\n" \
+"	float4 color = {0.0f,0.0f,0.0f,0.0f};\n" \
+"	float4 multiplyer = {0.0f,0.0f,0.0f,0.0f};\n" \
+"	float4 bokeh;\n" \
+"	const float radius2 = radius*2.0f;\n" \
+"	const int2 realCoordinate = coords + offsetOutput;\n" \
+"\n" \
+"	tempBoundingBox = read_imagef(boundingBox, SAMPLER_NEAREST, coords).s0;\n" \
+"\n" \
+"	if (tempBoundingBox > 0.0f) {\n" \
+"		const int2 bokehImageDim = get_image_dim(bokehImage);\n" \
+"		const int2 bokehImageCenter = bokehImageDim/2;\n" \
+"		const int2 minXY = max(realCoordinate - radius, zero);;\n" \
+"		const int2 maxXY = min(realCoordinate + radius, dimension);;\n" \
+"		int nx, ny;\n" \
+"\n" \
+"		float2 uv;\n" \
+"		int2 inputXy;\n" \
+"\n" \
+"		for (ny = minXY.y, inputXy.y = ny - offsetInput.y ; ny < maxXY.y ; ny +=step, inputXy.y+=step) {\n" \
+"			uv.y = ((realCoordinate.y-ny)/radius2)*bokehImageDim.y+bokehImageCenter.y;\n" \
+"\n" \
+"			for (nx = minXY.x, inputXy.x = nx - offsetInput.x; nx < maxXY.x ; nx +=step, inputXy.x+=step) {\n" \
+"				uv.x = ((realCoordinate.x-nx)/radius2)*bokehImageDim.x+bokehImageCenter.x;\n" \
+"				bokeh = read_imagef(bokehImage, SAMPLER_NEAREST, uv);\n" \
+"				color += bokeh * read_imagef(inputImage, SAMPLER_NEAREST, inputXy);\n" \
+"				multiplyer += bokeh;\n" \
+"			}\n" \
+"		}\n" \
+"		color /= multiplyer;\n" \
+"\n" \
+"	} else {\n" \
+"		int2 imageCoordinates = realCoordinate - offsetInput;\n" \
+"		color = read_imagef(inputImage, SAMPLER_NEAREST, imageCoordinates);\n" \
+"	}\n" \
+"\n" \
+"	write_imagef(output, coords, color);\n" \
+"}\n" \
+"\0";
diff --git a/source/blender/compositor/operations/COM_OutputFileOperation.h b/source/blender/compositor/operations/COM_OutputFileOperation.h
index 0e37432ca5b..9b9fb023467 100644
--- a/source/blender/compositor/operations/COM_OutputFileOperation.h
+++ b/source/blender/compositor/operations/COM_OutputFileOperation.h
@@ -49,7 +49,7 @@ public:
 	bool isOutputOperation(bool rendering) const {return true;}
 	void initExecution();
 	void deinitExecution();
-	const int getRenderPriority() const {return 7;}
+	const CompositorPriority getRenderPriority() const {return COM_PRIORITY_LOW;}
 };
 
 /* extra info for OpenEXR layers */
@@ -83,7 +83,7 @@ public:
 	bool isOutputOperation(bool rendering) const {return true;}
 	void initExecution();
 	void deinitExecution();
-	const int getRenderPriority() const {return 7;}
+	const CompositorPriority getRenderPriority() const {return COM_PRIORITY_LOW;}
 };
 
 #endif
diff --git a/source/blender/compositor/operations/COM_PreviewOperation.cpp b/source/blender/compositor/operations/COM_PreviewOperation.cpp
index a7b6fc93b25..4975f13a285 100644
--- a/source/blender/compositor/operations/COM_PreviewOperation.cpp
+++ b/source/blender/compositor/operations/COM_PreviewOperation.cpp
@@ -46,7 +46,6 @@ PreviewOperation::PreviewOperation() : NodeOperation()
 	this->input = NULL;
 	this->divider = 1.0f;
 	this->node = NULL;
-	this->priority = 0;
 }
 
 void PreviewOperation::initExecution()
@@ -129,7 +128,7 @@ void PreviewOperation::determineResolution(unsigned int resolution[], unsigned i
 	resolution[1] = height;
 }
 
-const int PreviewOperation::getRenderPriority() const
+const CompositorPriority PreviewOperation::getRenderPriority() const
 {
-	return this->priority;
+	return COM_PRIORITY_LOW;
 }
diff --git a/source/blender/compositor/operations/COM_PreviewOperation.h b/source/blender/compositor/operations/COM_PreviewOperation.h
index 8450b7fc556..3d1cd38a5ea 100644
--- a/source/blender/compositor/operations/COM_PreviewOperation.h
+++ b/source/blender/compositor/operations/COM_PreviewOperation.h
@@ -37,20 +37,18 @@ protected:
 	const bNodeTree *tree;
 	SocketReader *input;
 	float divider;
-	int priority;
 
 public:
 	PreviewOperation();
 	bool isOutputOperation(bool rendering) const {return true;}
 	void initExecution();
 	void deinitExecution();
-	const int getRenderPriority() const;
+	const CompositorPriority getRenderPriority() const;
 	
 	void executeRegion(rcti *rect, unsigned int tileNumber, MemoryBuffer **memoryBuffers);
 	void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
 	void setbNode(bNode *node) { this->node = node;}
 	void setbNodeTree(const bNodeTree *tree) { this->tree = tree;}
 	bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-	void setPriority(int priority) { this->priority = priority; }
 };
 #endif
diff --git a/source/blender/compositor/operations/COM_RotateOperation.cpp b/source/blender/compositor/operations/COM_RotateOperation.cpp
index 313e49d8609..af2633f0e53 100644
--- a/source/blender/compositor/operations/COM_RotateOperation.cpp
+++ b/source/blender/compositor/operations/COM_RotateOperation.cpp
@@ -43,7 +43,7 @@ void RotateOperation::initExecution()
 	this->degreeSocket->read(degree, 0, 0, COM_PS_NEAREST, NULL);
 	double rad;
 	if (this->doDegree2RadConversion) {
-		rad = DEG2RAD(degree[0]);
+		rad = DEG2RAD((double)degree[0]);
 	}
 	else {
 		rad = degree[0];
diff --git a/source/blender/compositor/operations/COM_TonemapOperation.cpp b/source/blender/compositor/operations/COM_TonemapOperation.cpp
index 56830f4970d..d8089bdf3ea 100644
--- a/source/blender/compositor/operations/COM_TonemapOperation.cpp
+++ b/source/blender/compositor/operations/COM_TonemapOperation.cpp
@@ -53,14 +53,14 @@ void TonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *in
 	float dr = output[0] + this->data->offset;
 	float dg = output[1] + this->data->offset;
 	float db = output[2] + this->data->offset;
-	output[0] /= ((dr == 0.f) ? 1.f : dr);
-	output[1] /= ((dg == 0.f) ? 1.f : dg);
-	output[2] /= ((db == 0.f) ? 1.f : db);
+	output[0] /= ((dr == 0.f) ? 1.0f : dr);
+	output[1] /= ((dg == 0.f) ? 1.0f : dg);
+	output[2] /= ((db == 0.f) ? 1.0f : db);
 	const float igm = avg->igm;
-	if (igm != 0.f) {
-		output[0] = pow((double)MAX2(output[0], 0.), (double)igm);
-		output[1] = pow((double)MAX2(output[1], 0.), (double)igm);
-		output[2] = pow((double)MAX2(output[2], 0.), (double)igm);
+	if (igm != 0.0f) {
+		output[0] = powf(MAX2(output[0], 0.0f), igm);
+		output[1] = powf(MAX2(output[1], 0.0f), igm);
+		output[2] = powf(MAX2(output[2], 0.0f), igm);
 	}
 
 	color[0] = output[0];
@@ -68,31 +68,31 @@ void TonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *in
 	color[2] = output[2];
 	color[3] = output[3];
 }
-void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void * data)
+void PhotoreceptorTonemapOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
-	AvgLogLum * avg = (AvgLogLum*)data;
+	AvgLogLum *avg = (AvgLogLum *)data;
 	NodeTonemap *ntm = this->data;
 
-	const float f = exp((double)-this->data->f);
-	const float m = (ntm->m > 0.f) ? ntm->m : (0.3f + 0.7f*pow((double)avg->auto_key, 1.4));
-	const float ic = 1.f - ntm->c, ia = 1.f - ntm->a;
+	const float f = expf(-this->data->f);
+	const float m = (ntm->m > 0.0f) ? ntm->m : (0.3f + 0.7f * powf(avg->auto_key, 1.4f));
+	const float ic = 1.0f - ntm->c, ia = 1.0f - ntm->a;
 
 	float output[4];
 	this->imageReader->read(output, x, y, inputBuffers, NULL);
 
-	const float L = 0.212671f*output[0] + 0.71516f*output[1] + 0.072169f*output[2];
-	float I_l = output[0] + ic*(L - output[0]);
-	float I_g = avg->cav[0] + ic*(avg->lav - avg->cav[0]);
-	float I_a = I_l + ia*(I_g - I_l);
-	output[0] /= (output[0] + pow((double)f*I_a, (double)m));
-	I_l = output[1] + ic*(L - output[1]);
-	I_g = avg->cav[1] + ic*(avg->lav - avg->cav[1]);
-	I_a = I_l + ia*(I_g - I_l);
-	output[1] /= (output[1] + pow((double)f*I_a,(double)m));
-	I_l = output[2] + ic*(L - output[2]);
-	I_g = avg->cav[2] + ic*(avg->lav - avg->cav[2]);
-	I_a = I_l + ia*(I_g - I_l);
-	output[2] /= (output[2] + pow((double)f*I_a, (double)m));
+	const float L = 0.212671f * output[0] + 0.71516f * output[1] + 0.072169f * output[2];
+	float I_l = output[0] + ic * (L - output[0]);
+	float I_g = avg->cav[0] + ic * (avg->lav - avg->cav[0]);
+	float I_a = I_l + ia * (I_g - I_l);
+	output[0] /= (output[0] + powf(f * I_a, m));
+	I_l = output[1] + ic * (L - output[1]);
+	I_g = avg->cav[1] + ic * (avg->lav - avg->cav[1]);
+	I_a = I_l + ia * (I_g - I_l);
+	output[1] /= (output[1] + powf(f * I_a, m));
+	I_l = output[2] + ic * (L - output[2]);
+	I_g = avg->cav[2] + ic * (avg->lav - avg->cav[2]);
+	I_a = I_l + ia * (I_g - I_l);
+	output[2] /= (output[2] + powf(f * I_a, m));
 
 	color[0] = output[0];
 	color[1] = output[1];
@@ -133,20 +133,20 @@ void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuff
 
 		float * buffer = tile->getBuffer();
 
-		float lsum = 0;
+		float lsum = 0.0f;
 		int p = tile->getWidth() * tile->getHeight();
 		float *bc = buffer;
 		float avl, maxl = -1e10f, minl = 1e10f;
-		const float sc = 1.f/(p);
+		const float sc = 1.0f / p;
 		float Lav = 0.f;
 		float cav[4] = {0.0f,0.0f,0.0f,0.0f};
 		while (p--) {
-			float L = 0.212671f*bc[0] + 0.71516f*bc[1] + 0.072169f*bc[2];
+			float L = 0.212671f * bc[0] + 0.71516f * bc[1] + 0.072169f * bc[2];
 			Lav += L;
 			cav[0] += bc[0];
 			cav[1] += bc[1];
 			cav[2] += bc[2];
-			lsum += (float)log((double)MAX2(L, 0.0) + 1e-5);
+			lsum += logf(MAX2(L, 0.0f) + 1e-5f);
 			maxl = (L > maxl) ? L : maxl;
 			minl = (L < minl) ? L : minl;
 			bc+=4;
@@ -155,7 +155,7 @@ void *TonemapOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuff
 		data->cav[0] = cav[0]*sc;
 		data->cav[1] = cav[1]*sc;
 		data->cav[2] = cav[2]*sc;
-		maxl = log((double)maxl + 1e-5); minl = log((double)minl + 1e-5f); avl = lsum*sc;
+		maxl = log((double)maxl + 1e-5); minl = log((double)minl + 1e-5); avl = lsum * sc;
 		data->auto_key = (maxl > minl) ? ((maxl - avl) / (maxl - minl)) : 1.f;
 		float al = exp((double)avl);
 		data->al = (al == 0.f) ? 0.f : (this->data->key / al);
diff --git a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
index f14de097dfd..270fedc174b 100644
--- a/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
+++ b/source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
@@ -89,7 +89,7 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
 					if (nx == x && ny == y) {
 						/* pass */
 					}
-					else if (size>=  fabs(dx) && size >= fabs(dy)) {
+					else if (size >= fabsf(dx) && size >= fabsf(dy)) {
 						float u = 256 + dx*256/size;
 						float v = 256 + dy*256/size;
 						inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers);
@@ -104,9 +104,9 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
 				}
 			}
 		}
-		color[0] = tempColor[0]*(1.0/overallmultiplyerr);
-		color[1] = tempColor[1]*(1.0/overallmultiplyerg);
-		color[2] = tempColor[2]*(1.0/overallmultiplyerb);
+		color[0] = tempColor[0] * (1.0f / overallmultiplyerr);
+		color[1] = tempColor[1] * (1.0f / overallmultiplyerg);
+		color[2] = tempColor[2] * (1.0f / overallmultiplyerb);
 		color[3] = 1.0f;
 	}
 
diff --git a/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp b/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp
index 44b4c26fb64..809c688195f 100644
--- a/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp
+++ b/source/blender/compositor/operations/COM_ViewerBaseOperation.cpp
@@ -50,8 +50,9 @@ ViewerBaseOperation::ViewerBaseOperation() : NodeOperation()
 
 void ViewerBaseOperation::initExecution()
 {
-	// When initializing the tree during initial load the width and height can be zero.
-	initImage();
+	if (isActiveViewerOutput()) {
+		initImage();
+	}
 }
 
 void ViewerBaseOperation::initImage()
@@ -79,7 +80,6 @@ void ViewerBaseOperation::initImage()
 }
 void ViewerBaseOperation:: updateImage(rcti *rect)
 {
-	/// @todo: introduce new event to update smaller area
 	WM_main_add_notifier(NC_WINDOW|ND_DRAW, NULL);
 }
 
@@ -88,12 +88,12 @@ void ViewerBaseOperation::deinitExecution()
 	this->outputBuffer = NULL;
 }
 
-const int ViewerBaseOperation::getRenderPriority() const
+const CompositorPriority ViewerBaseOperation::getRenderPriority() const
 {
 	if (this->isActiveViewerOutput()) {
-		return 8;
+		return COM_PRIORITY_HIGH;
 	}
 	else {
-		return 0;
+		return COM_PRIORITY_LOW;
 	}
 }
diff --git a/source/blender/compositor/operations/COM_ViewerBaseOperation.h b/source/blender/compositor/operations/COM_ViewerBaseOperation.h
index 58101911550..51fa8cecc0d 100644
--- a/source/blender/compositor/operations/COM_ViewerBaseOperation.h
+++ b/source/blender/compositor/operations/COM_ViewerBaseOperation.h
@@ -42,7 +42,7 @@ protected:
 	bool doColorPredivide;
 
 public:
-	bool isOutputOperation(bool rendering) const {return true;}
+	bool isOutputOperation(bool rendering) const {return isActiveViewerOutput();}
 	void initExecution();
 	void deinitExecution();
 	void setImage(Image *image) {this->image = image;}
@@ -56,7 +56,7 @@ public:
 	float getCenterX() { return this->centerX; }
 	float getCenterY() { return this->centerY; }
 	OrderOfChunks getChunkOrder() { return this->chunkOrder; }
-	const int getRenderPriority() const;
+	const CompositorPriority getRenderPriority() const;
 	void setColorManagement(bool doColorManagement) {this->doColorManagement = doColorManagement;}
 	void setColorPredivide(bool doColorPredivide) {this->doColorPredivide = doColorPredivide;}
 	bool isViewerOperation() {return true;}
diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.cpp b/source/blender/compositor/operations/COM_WriteBufferOperation.cpp
index 498add2fc87..222b879645c 100644
--- a/source/blender/compositor/operations/COM_WriteBufferOperation.cpp
+++ b/source/blender/compositor/operations/COM_WriteBufferOperation.cpp
@@ -111,10 +111,9 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber, Me
 	memoryBuffer->setCreatedState();
 }
 
-void WriteBufferOperation::executeOpenCLRegion(cl_context context, cl_program program, cl_command_queue queue, rcti *rect, unsigned int chunkNumber, MemoryBuffer** inputMemoryBuffers)
+void WriteBufferOperation::executeOpenCLRegion(cl_context context, cl_program program, cl_command_queue queue, rcti *rect, unsigned int chunkNumber, MemoryBuffer** inputMemoryBuffers, MemoryBuffer* outputBuffer)
 {
-	MemoryBuffer *outputMemoryBuffer = this->getMemoryProxy()->getBuffer();// @todo wrong implementation needs revision
-	float *outputFloatBuffer = outputMemoryBuffer->getBuffer();
+	float *outputFloatBuffer = outputBuffer->getBuffer();
 	cl_int error;
 	/*
 	 * 1. create cl_mem from outputbuffer
@@ -125,8 +124,8 @@ void WriteBufferOperation::executeOpenCLRegion(cl_context context, cl_program pr
 	 * note: list of cl_mem will be filled by 2, and needs to be cleaned up by 4
 	 */
 	// STEP 1
-	const unsigned int outputBufferWidth = outputMemoryBuffer->getWidth();
-	const unsigned int outputBufferHeight = outputMemoryBuffer->getHeight();
+	const unsigned int outputBufferWidth = outputBuffer->getWidth();
+	const unsigned int outputBufferHeight = outputBuffer->getHeight();
 
 	const cl_image_format imageFormat = {
 		CL_RGBA,
@@ -141,19 +140,26 @@ void WriteBufferOperation::executeOpenCLRegion(cl_context context, cl_program pr
 	clMemToCleanUp->push_back(clOutputBuffer);
 	list<cl_kernel> *clKernelsToCleanUp = new list<cl_kernel>();
 
-	this->input->executeOpenCL(context, program, queue, outputMemoryBuffer, clOutputBuffer, inputMemoryBuffers, clMemToCleanUp, clKernelsToCleanUp);
+	this->input->executeOpenCL(context, program, queue, outputBuffer, clOutputBuffer, inputMemoryBuffers, clMemToCleanUp, clKernelsToCleanUp);
 
 	// STEP 3
 
 	size_t origin[3] = {0,0,0};
 	size_t region[3] = {outputBufferWidth,outputBufferHeight,1};
 
+//	clFlush(queue);
+//	clFinish(queue);
+
 	error = clEnqueueBarrier(queue);
 	if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));	}
 	error = clEnqueueReadImage(queue, clOutputBuffer, CL_TRUE, origin, region, 0, 0, outputFloatBuffer, 0, NULL, NULL);
 	if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));	}
+	
+	this->getMemoryProxy()->getBuffer()->copyContentFrom(outputBuffer);
+	
 	// STEP 4
 
+	
 	while (clMemToCleanUp->size()>0) {
 		cl_mem mem = clMemToCleanUp->front();
 		error = clReleaseMemObject(mem);
diff --git a/source/blender/compositor/operations/COM_WriteBufferOperation.h b/source/blender/compositor/operations/COM_WriteBufferOperation.h
index b17122d68f0..6f2c49c49bd 100644
--- a/source/blender/compositor/operations/COM_WriteBufferOperation.h
+++ b/source/blender/compositor/operations/COM_WriteBufferOperation.h
@@ -46,7 +46,7 @@ public:
 	void initExecution();
 	void deinitExecution();
 	void setbNodeTree(const bNodeTree *tree) {this->tree = tree;}
-	void executeOpenCLRegion(cl_context context, cl_program program, cl_command_queue queue, rcti *rect, unsigned int chunkNumber, MemoryBuffer** memoryBuffers);
+	void executeOpenCLRegion(cl_context context, cl_program program, cl_command_queue queue, rcti *rect, unsigned int chunkNumber, MemoryBuffer** memoryBuffers, MemoryBuffer* outputBuffer);
 
 };
 #endif