Merge branch 'master' into blender2.8

17 files changed, 116 insertions, 116 deletions

diff --git a/source/blender/compositor/COM_compositor.h b/source/blender/compositor/COM_compositor.h
index dbdcb8b4924..b481b4ec100 100644
--- a/source/blender/compositor/COM_compositor.h
+++ b/source/blender/compositor/COM_compositor.h
@@ -281,13 +281,13 @@ extern "C" {
  * It can be executed during editing (blenkernel/node.c) or rendering
  * (renderer/pipeline.c)
  *
- * \param rd [struct RenderData]
+ * \param rd: [struct RenderData]
  *   Render data for this composite, this won't always belong to a scene.
  *
- * \param editingtree [struct bNodeTree]
+ * \param editingtree: [struct bNodeTree]
  *   reference to the compositor editing tree
  *
- * \param rendering [true false]
+ * \param rendering: [true false]
  *    This parameter determines whether the function is called from rendering (true) or editing (false).
  *    based on this setting the system will work differently:
  *     - during rendering only Composite & the File output node will be calculated
@@ -304,10 +304,10 @@ extern "C" {
  *     - output nodes can have different priorities in the WorkScheduler.
  * This is implemented in the COM_execute function.
  *
- * \param viewSettings
+ * \param viewSettings:
  *   reference to view settings used for color management
  *
- * \param displaySettings
+ * \param displaySettings:
  *   reference to display settings used for color management
  *
  * OCIO_TODO: this options only used in rare cases, namely in output file node,
diff --git a/source/blender/compositor/intern/COM_CPUDevice.h b/source/blender/compositor/intern/COM_CPUDevice.h
index 52dcbb3a168..d3b63f0d079 100644
--- a/source/blender/compositor/intern/COM_CPUDevice.h
+++ b/source/blender/compositor/intern/COM_CPUDevice.h
@@ -35,7 +35,7 @@ public:
 
 	/**
 	 * \brief execute a WorkPackage
-	 * \param work the WorkPackage to execute
+	 * \param work: the WorkPackage to execute
 	 */
 	void execute(WorkPackage *work);
 
diff --git a/source/blender/compositor/intern/COM_Converter.h b/source/blender/compositor/intern/COM_Converter.h
index 3aaf0545222..642f51ee7e5 100644
--- a/source/blender/compositor/intern/COM_Converter.h
+++ b/source/blender/compositor/intern/COM_Converter.h
@@ -63,8 +63,8 @@ public:
 	 *
 	 * \note this method is called when conversion is needed.
 	 *
-	 * \param link the NodeLink what needs conversion
-	 * \param system the ExecutionSystem to add the conversion to.
+	 * \param link: the NodeLink what needs conversion
+	 * \param system: the ExecutionSystem to add the conversion to.
 	 * \see NodeLink - a link between two sockets
 	 */
 	static NodeOperation *convertDataType(NodeOperationOutput *from, NodeOperationInput *to);
@@ -75,8 +75,8 @@ public:
 	 * \note Conversion logic is implemented in this method
 	 * \see InputSocketResizeMode for the possible conversions.
 	 *
-	 * \param link the NodeLink what needs conversion
-	 * \param system the ExecutionSystem to add the conversion to.
+	 * \param link: the NodeLink what needs conversion
+	 * \param system: the ExecutionSystem to add the conversion to.
 	 * \see NodeLink - a link between two sockets
 	 */
 	static void convertResolution(NodeOperationBuilder &builder, NodeOperationOutput *fromSocket, NodeOperationInput *toSocket);
diff --git a/source/blender/compositor/intern/COM_Device.h b/source/blender/compositor/intern/COM_Device.h
index 4d6e1673aa1..abd0dfa5749 100644
--- a/source/blender/compositor/intern/COM_Device.h
+++ b/source/blender/compositor/intern/COM_Device.h
@@ -51,7 +51,7 @@ public:
 
 	/**
 	 * \brief execute a WorkPackage
-	 * \param work the WorkPackage to execute
+	 * \param work: the WorkPackage to execute
 	 */
 	virtual void execute(WorkPackage *work) = 0;
 
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.h b/source/blender/compositor/intern/COM_ExecutionGroup.h
index f85c1759d8f..8f170aab2fb 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.h
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.h
@@ -181,7 +181,7 @@ private:
 	// methods
 	/**
 	 * \brief check whether parameter operation can be added to the execution group
-	 * \param operation the operation to be added
+	 * \param operation: the operation to be added
 	 */
 	bool canContainOperation(NodeOperation *operation);
 
@@ -210,9 +210,9 @@ private:
 	/**
 	 * \brief try to schedule a specific chunk.
 	 * \note scheduling succeeds when all input requirements are met and the chunks hasn't been scheduled yet.
-	 * \param graph
-	 * \param xChunk
-	 * \param yChunk
+	 * \param graph:
+	 * \param xChunk:
+	 * \param yChunk:
 	 * \return [true:false]
 	 * true: package(s) are scheduled
 	 * false: scheduling is deferred (depending workpackages are scheduled)
@@ -223,8 +223,8 @@ private:
 	 * \brief try to schedule a specific area.
 	 * \note Check if a certain area is available, when not available this are will be checked.
 	 * \note This method is called from other ExecutionGroup's.
-	 * \param graph
-	 * \param rect
+	 * \param graph:
+	 * \param rect:
 	 * \return [true:false]
 	 * true: package(s) are scheduled
 	 * false: scheduling is deferred (depending workpackages are scheduled)
@@ -233,16 +233,16 @@ private:
 
 	/**
 	 * \brief add a chunk to the WorkScheduler.
-	 * \param chunknumber
+	 * \param chunknumber:
 	 */
 	bool scheduleChunk(unsigned int chunkNumber);
 
 	/**
 	 * \brief determine the area of interest of a certain input area
 	 * \note This method only evaluates a single ReadBufferOperation
-	 * \param input the input area
-	 * \param readOperation The ReadBufferOperation where the area needs to be evaluated
-	 * \param output the area needed of the ReadBufferOperation. Result
+	 * \param input: the input area
+	 * \param readOperation: The ReadBufferOperation where the area needs to be evaluated
+	 * \param output: the area needed of the ReadBufferOperation. Result
 	 */
 	void determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
@@ -256,8 +256,8 @@ public:
 	 * \brief add an operation to this ExecutionGroup
 	 * \note this method will add input of the operations recursively
 	 * \note this method can create multiple ExecutionGroup's
-	 * \param system
-	 * \param operation
+	 * \param system:
+	 * \param operation:
 	 * \return True if the operation was successfully added
 	 */
 	bool addOperation(NodeOperation *operation);
@@ -272,19 +272,19 @@ public:
 
 	/**
 	 * \brief set whether this ExecutionGroup is an output
-	 * \param isOutput
+	 * \param isOutput:
 	 */
 	void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; }
 
 	/**
 	 * \brief determine the resolution of this ExecutionGroup
-	 * \param resolution
+	 * \param resolution:
 	 */
 	void determineResolution(unsigned int resolution[2]);
 
 	/**
 	 * \brief set the resolution of this executiongroup
-	 * \param resolution
+	 * \param resolution:
 	 */
 	void setResolution(unsigned int resolution[2]) { this->m_width = resolution[0]; this->m_height = resolution[1]; }
 
@@ -325,7 +325,7 @@ public:
 	/**
 	 * \brief get all inputbuffers needed to calculate an chunk
 	 * \note all inputbuffers must be executed
-	 * \param chunkNumber the chunk to be calculated
+	 * \param chunkNumber: the chunk to be calculated
 	 * \return (MemoryBuffer **) the inputbuffers
 	 */
 	MemoryBuffer **getInputBuffersCPU();
@@ -333,23 +333,23 @@ public:
 	/**
 	 * \brief get all inputbuffers needed to calculate an chunk
 	 * \note all inputbuffers must be executed
-	 * \param chunkNumber the chunk to be calculated
+	 * \param chunkNumber: the chunk to be calculated
 	 * \return (MemoryBuffer **) the inputbuffers
 	 */
 	MemoryBuffer **getInputBuffersOpenCL(int chunkNumber);
 
 	/**
 	 * \brief allocate the outputbuffer of a chunk
-	 * \param chunkNumber the number of the chunk in the ExecutionGroup
-	 * \param rect the rect of that chunk
+	 * \param chunkNumber: the number of the chunk in the ExecutionGroup
+	 * \param rect: the rect of that chunk
 	 * \see determineChunkRect
 	 */
 	MemoryBuffer *allocateOutputBuffer(int chunkNumber, rcti *rect);
 
 	/**
 	 * \brief after a chunk is executed the needed resources can be freed or unlocked.
-	 * \param chunknumber
-	 * \param memorybuffers
+	 * \param chunknumber:
+	 * \param memorybuffers:
 	 */
 	void finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers);
 
@@ -372,7 +372,7 @@ public:
 	 * After determining the order of the chunks the chunks will be scheduled
 	 *
 	 * \see ViewerOperation
-	 * \param system
+	 * \param system:
 	 */
 	void execute(ExecutionSystem *system);
 
@@ -380,7 +380,7 @@ public:
 	 * \brief this method determines the MemoryProxy's where this execution group depends on.
 	 * \note After this method determineDependingAreaOfInterest can be called to determine
 	 * \note the area of the MemoryProxy.creator that has to be executed.
-	 * \param memoryProxies result
+	 * \param memoryProxies: result
 	 */
 	void determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies);
 
diff --git a/source/blender/compositor/intern/COM_ExecutionSystem.h b/source/blender/compositor/intern/COM_ExecutionSystem.h
index 83c2918f480..13e393a4236 100644
--- a/source/blender/compositor/intern/COM_ExecutionSystem.h
+++ b/source/blender/compositor/intern/COM_ExecutionSystem.h
@@ -147,8 +147,8 @@ public:
 	 * \brief Create a new ExecutionSystem and initialize it with the
 	 * editingtree.
 	 *
-	 * \param editingtree [bNodeTree *]
-	 * \param rendering [true false]
+	 * \param editingtree: [bNodeTree *]
+	 * \param rendering: [true false]
 	 */
 	ExecutionSystem(RenderData *rd, Scene *scene, bNodeTree *editingtree, bool rendering, bool fastcalculation,
 	                const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings,
diff --git a/source/blender/compositor/intern/COM_MemoryBuffer.h b/source/blender/compositor/intern/COM_MemoryBuffer.h
index 085cf8708d7..17ee17316fb 100644
--- a/source/blender/compositor/intern/COM_MemoryBuffer.h
+++ b/source/blender/compositor/intern/COM_MemoryBuffer.h
@@ -279,7 +279,7 @@ public:
 
 	/**
 	 * \brief add the content from otherBuffer to this MemoryBuffer
-	 * \param otherBuffer source buffer
+	 * \param otherBuffer: source buffer
 	 *
 	 * \note take care when running this on a new buffer since it wont fill in
 	 *       uninitialized values in areas where the buffers don't overlap.
diff --git a/source/blender/compositor/intern/COM_MemoryProxy.h b/source/blender/compositor/intern/COM_MemoryProxy.h
index ee5dd684b38..7da7f871036 100644
--- a/source/blender/compositor/intern/COM_MemoryProxy.h
+++ b/source/blender/compositor/intern/COM_MemoryProxy.h
@@ -73,7 +73,7 @@ public:
 
 	/**
 	 * \brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
-	 * \param group the ExecutionGroup to set
+	 * \param group: the ExecutionGroup to set
 	 */
 	void setExecutor(ExecutionGroup *executor) { this->m_executor = executor; }
 
@@ -84,7 +84,7 @@ public:
 
 	/**
 	 * \brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
-	 * \param operation
+	 * \param operation:
 	 */
 	void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; }
 
diff --git a/source/blender/compositor/intern/COM_Node.h b/source/blender/compositor/intern/COM_Node.h
index 9dea9d715a8..ab70bd6e617 100644
--- a/source/blender/compositor/intern/COM_Node.h
+++ b/source/blender/compositor/intern/COM_Node.h
@@ -105,13 +105,13 @@ public:
 	/**
 	 * \brief set the reference to the bNode
 	 * \note used in Node instances to receive the storage/settings and complex node for highlight during execution
-	 * \param bNode
+	 * \param bNode:
 	 */
 	void setbNode(bNode *node) {this->m_editorNode = node;}
 
 	/**
 	 * \brief set the reference to the bNodeTree
-	 * \param bNodeTree
+	 * \param bNodeTree:
 	 */
 	void setbNodeTree(bNodeTree *nodetree) {this->m_editorNodeTree = nodetree;}
 
@@ -127,21 +127,21 @@ public:
 
 	/**
 	 * get the reference to a certain outputsocket
-	 * \param index
+	 * \param index:
 	 * the index of the needed outputsocket
 	 */
 	NodeOutput *getOutputSocket(const unsigned int index) const;
 
 	/**
 	 * get the reference to the first outputsocket
-	 * \param index
+	 * \param index:
 	 * the index of the needed outputsocket
 	 */
 	inline NodeOutput *getOutputSocket() const { return getOutputSocket(0); }
 
 	/**
 	 * get the reference to a certain inputsocket
-	 * \param index
+	 * \param index:
 	 * the index of the needed inputsocket
 	 */
 	NodeInput *getInputSocket(const unsigned int index) const;
@@ -153,7 +153,7 @@ public:
 
 	/**
 	 * \brief Is this node in the active group (the group that is being edited)
-	 * \param isInActiveGroup
+	 * \param isInActiveGroup:
 	 */
 	void setIsInActiveGroup(bool value) { this->m_inActiveGroup = value; }
 
@@ -170,8 +170,8 @@ public:
 	 *
 	 * \todo this must be described further
 	 *
-	 * \param system the ExecutionSystem where the operations need to be added
-	 * \param context reference to the CompositorContext
+	 * \param system: the ExecutionSystem where the operations need to be added
+	 * \param context: reference to the CompositorContext
 	 */
 	virtual void convertToOperations(NodeConverter &converter, const CompositorContext &context) const = 0;
 
@@ -193,7 +193,7 @@ protected:
 	/**
 	 * \brief add an NodeInput to the collection of inputsockets
 	 * \note may only be called in an constructor
-	 * \param socket the NodeInput to add
+	 * \param socket: the NodeInput to add
 	 */
 	void addInputSocket(DataType datatype);
 	void addInputSocket(DataType datatype, bNodeSocket *socket);
@@ -201,7 +201,7 @@ protected:
 	/**
 	 * \brief add an NodeOutput to the collection of outputsockets
 	 * \note may only be called in an constructor
-	 * \param socket the NodeOutput to add
+	 * \param socket: the NodeOutput to add
 	 */
 	void addOutputSocket(DataType datatype);
 	void addOutputSocket(DataType datatype, bNodeSocket *socket);
diff --git a/source/blender/compositor/intern/COM_NodeOperation.h b/source/blender/compositor/intern/COM_NodeOperation.h
index c0957d57040..10161343444 100644
--- a/source/blender/compositor/intern/COM_NodeOperation.h
+++ b/source/blender/compositor/intern/COM_NodeOperation.h
@@ -143,8 +143,8 @@ public:
 	/**
 	 * \brief determine the resolution of this node
 	 * \note this method will not set the resolution, this is the responsibility of the caller
-	 * \param resolution the result of this operation
-	 * \param preferredResolution the preferable resolution as no resolution could be determined
+	 * \param resolution: the result of this operation
+	 * \param preferredResolution: the preferable resolution as no resolution could be determined
 	 */
 	virtual void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
@@ -155,7 +155,7 @@ public:
 	 *
 	 * \see ExecutionSystem
 	 * \group check
-	 * \param rendering [true false]
+	 * \param rendering: [true false]
 	 *  true: rendering
 	 *  false: editing
 	 *
@@ -171,9 +171,9 @@ public:
 	/**
 	 * \brief when a chunk is executed by a CPUDevice, this method is called
 	 * \ingroup execution
-	 * \param rect the rectangle of the chunk (location and size)
-	 * \param chunkNumber the chunkNumber to be calculated
-	 * \param memoryBuffers all input MemoryBuffer's needed
+	 * \param rect: the rectangle of the chunk (location and size)
+	 * \param chunkNumber: the chunkNumber to be calculated
+	 * \param memoryBuffers: all input MemoryBuffer's needed
 	 */
 	virtual void executeRegion(rcti * /*rect*/,
 	                           unsigned int /*chunkNumber*/) {}
@@ -182,13 +182,13 @@ public:
 	 * \brief when a chunk is executed by an OpenCLDevice, this method is called
 	 * \ingroup execution
 	 * \note this method is only implemented in WriteBufferOperation
-	 * \param context the OpenCL context
-	 * \param program the OpenCL program containing all compositor kernels
-	 * \param queue the OpenCL command queue of the device the chunk is executed on
-	 * \param rect the rectangle of the chunk (location and size)
-	 * \param chunkNumber the chunkNumber to be calculated
-	 * \param memoryBuffers all input MemoryBuffer's needed
-	 * \param outputBuffer the outputbuffer to write to
+	 * \param context: the OpenCL context
+	 * \param program: the OpenCL program containing all compositor kernels
+	 * \param queue: the OpenCL command queue of the device the chunk is executed on
+	 * \param rect: the rectangle of the chunk (location and size)
+	 * \param chunkNumber: the chunkNumber to be calculated
+	 * \param memoryBuffers: all input MemoryBuffer's needed
+	 * \param outputBuffer: the outputbuffer to write to
 	 */
 	virtual void executeOpenCLRegion(OpenCLDevice * /*device*/,
 	                                 rcti * /*rect*/,
@@ -199,14 +199,14 @@ public:
 	/**
 	 * \brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice
 	 * \ingroup execution
-	 * \param context the OpenCL context
-	 * \param program the OpenCL program containing all compositor kernels
-	 * \param queue the OpenCL command queue of the device the chunk is executed on
-	 * \param outputMemoryBuffer the allocated memory buffer in main CPU memory
-	 * \param clOutputBuffer the allocated memory buffer in OpenCLDevice memory
-	 * \param inputMemoryBuffers all input MemoryBuffer's needed
-	 * \param clMemToCleanUp all created cl_mem references must be added to this list. Framework will clean this after execution
-	 * \param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
+	 * \param context: the OpenCL context
+	 * \param program: the OpenCL program containing all compositor kernels
+	 * \param queue: the OpenCL command queue of the device the chunk is executed on
+	 * \param outputMemoryBuffer: the allocated memory buffer in main CPU memory
+	 * \param clOutputBuffer: the allocated memory buffer in OpenCLDevice memory
+	 * \param inputMemoryBuffers: all input MemoryBuffer's needed
+	 * \param clMemToCleanUp: all created cl_mem references must be added to this list. Framework will clean this after execution
+	 * \param clKernelsToCleanUp: all created cl_kernel references must be added to this list. Framework will clean this after execution
 	 */
 	virtual void executeOpenCL(OpenCLDevice * /*device*/,
 	                           MemoryBuffer * /*outputMemoryBuffer*/,
@@ -222,7 +222,7 @@ public:
 
 	/**
 	 * \brief set the resolution
-	 * \param resolution the resolution to set
+	 * \param resolution: the resolution to set
 	 */
 	void setResolution(unsigned int resolution[2]) {
 		if (!isResolutionSet()) {
@@ -271,7 +271,7 @@ public:
 
 	/**
 	 * \brief set the index of the input socket that will determine the resolution of this operation
-	 * \param index the index to set
+	 * \param index: the index to set
 	 */
 	void setResolutionInputSocketIndex(unsigned int index);
 
@@ -397,8 +397,8 @@ public:
 
 	/**
 	 * \brief determine the resolution of this data going through this socket
-	 * \param resolution the result of this operation
-	 * \param preferredResolution the preferable resolution as no resolution could be determined
+	 * \param resolution: the result of this operation
+	 * \param preferredResolution: the preferable resolution as no resolution could be determined
 	 */
 	void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
diff --git a/source/blender/compositor/intern/COM_OpenCLDevice.h b/source/blender/compositor/intern/COM_OpenCLDevice.h
index 4f2c71e23e7..940ed233ecc 100644
--- a/source/blender/compositor/intern/COM_OpenCLDevice.h
+++ b/source/blender/compositor/intern/COM_OpenCLDevice.h
@@ -66,10 +66,10 @@ private:
 public:
 	/**
 	 * \brief constructor with opencl device
-	 * \param context
-	 * \param device
-	 * \param program
-	 * \param vendorID
+	 * \param context:
+	 * \param device:
+	 * \param program:
+	 * \param vendorID:
 	 */
 	OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId);
 
@@ -90,13 +90,13 @@ public:
 
 	/**
 	 * \brief execute a WorkPackage
-	 * \param work the WorkPackage to execute
+	 * \param work: the WorkPackage to execute
 	 */
 	void execute(WorkPackage *work);
 
 	/**
 	 * \brief determine an image format
-	 * \param memorybuffer
+	 * \param memorybuffer:
 	 */
 	static const cl_image_format *determineImageFormat(MemoryBuffer *memoryBuffer);
 
diff --git a/source/blender/compositor/intern/COM_SocketReader.h b/source/blender/compositor/intern/COM_SocketReader.h
index 1e0629ae2b4..ec1c200fd81 100644
--- a/source/blender/compositor/intern/COM_SocketReader.h
+++ b/source/blender/compositor/intern/COM_SocketReader.h
@@ -58,10 +58,10 @@ protected:
 	/**
 	 * \brief calculate a single pixel
 	 * \note this method is called for non-complex
-	 * \param result is a float[4] array to store the result
-	 * \param x the x-coordinate of the pixel to calculate in image space
-	 * \param y the y-coordinate of the pixel to calculate in image space
-	 * \param inputBuffers chunks that can be read by their ReadBufferOperation.
+	 * \param result: is a float[4] array to store the result
+	 * \param x: the x-coordinate of the pixel to calculate in image space
+	 * \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 executePixelSampled(float /*output*/[4],
 	                                 float /*x*/,
@@ -71,11 +71,11 @@ protected:
 	/**
 	 * \brief calculate a single pixel
 	 * \note this method is called for complex
-	 * \param result is a float[4] array to store the result
-	 * \param x the x-coordinate of the pixel to calculate in image space
-	 * \param y the y-coordinate of the pixel to calculate in image space
-	 * \param inputBuffers chunks that can be read by their ReadBufferOperation.
-	 * \param chunkData chunk specific data a during execution time.
+	 * \param result: is a float[4] array to store the result
+	 * \param x: the x-coordinate of the pixel to calculate in image space
+	 * \param y: the y-coordinate of the pixel to calculate in image space
+	 * \param inputBuffers: chunks that can be read by their ReadBufferOperation.
+	 * \param chunkData: chunk specific data a during execution time.
 	 */
 	virtual void executePixel(float output[4], int x, int y, void * /*chunkData*/) {
 		executePixelSampled(output, x, y, COM_PS_NEAREST);
@@ -84,12 +84,12 @@ protected:
 	/**
 	 * \brief calculate a single pixel using an EWA filter
 	 * \note this method is called for complex
-	 * \param result is a float[4] array to store the result
-	 * \param x the x-coordinate of the pixel to calculate in image space
-	 * \param y the y-coordinate of the pixel to calculate in image space
-	 * \param dx
-	 * \param dy
-	 * \param inputBuffers chunks that can be read by their ReadBufferOperation.
+	 * \param result: is a float[4] array to store the result
+	 * \param x: the x-coordinate of the pixel to calculate in image space
+	 * \param y: the y-coordinate of the pixel to calculate in image space
+	 * \param dx:
+	 * \param dy:
+	 * \param inputBuffers: chunks that can be read by their ReadBufferOperation.
 	 */
 	virtual void executePixelFiltered(float /*output*/[4],
 	                                  float /*x*/, float /*y*/,
diff --git a/source/blender/compositor/intern/COM_WorkPackage.h b/source/blender/compositor/intern/COM_WorkPackage.h
index 9d8efa12ca5..0cfabcae4f2 100644
--- a/source/blender/compositor/intern/COM_WorkPackage.h
+++ b/source/blender/compositor/intern/COM_WorkPackage.h
@@ -45,8 +45,8 @@ private:
 public:
 	/**
 	 * constructor
-	 * \param group the ExecutionGroup
-	 * \param chunkNumber the number of the chunk
+	 * \param group: the ExecutionGroup
+	 * \param chunkNumber: the number of the chunk
 	 */
 	WorkPackage(ExecutionGroup *group, unsigned int chunkNumber);
 
diff --git a/source/blender/compositor/intern/COM_WorkScheduler.h b/source/blender/compositor/intern/COM_WorkScheduler.h
index 6b134c8a4c6..6927127b63d 100644
--- a/source/blender/compositor/intern/COM_WorkScheduler.h
+++ b/source/blender/compositor/intern/COM_WorkScheduler.h
@@ -61,8 +61,8 @@ public:
 	 * when ExecutionGroup.isOpenCL is set the work will be handled by a OpenCLDevice
 	 * otherwise the work is scheduled for an CPUDevice
 	 * \see ExecutionGroup.execute
-	 * \param group the execution group
-	 * \param chunkNumber the number of the chunk in the group to be executed
+	 * \param group: the execution group
+	 * \param chunkNumber: the number of the chunk in the group to be executed
 	 */
 	static void schedule(ExecutionGroup *group, int chunkNumber);
 
diff --git a/source/blender/compositor/operations/COM_BokehImageOperation.h b/source/blender/compositor/operations/COM_BokehImageOperation.h
index c4616e5fecb..510ff6377a0 100644
--- a/source/blender/compositor/operations/COM_BokehImageOperation.h
+++ b/source/blender/compositor/operations/COM_BokehImageOperation.h
@@ -90,18 +90,18 @@ private:
 	/**
 	 * \brief determine the coordinate of a flap cornder
 	 *
-	 * \param r result in bokehimage space are stored [x,y]
-	 * \param flapNumber the flap number to calculate
-	 * \param distance the lens distance is used to simulate lens shifts
+	 * \param r: result in bokehimage space are stored [x,y]
+	 * \param flapNumber: the flap number to calculate
+	 * \param distance: the lens distance is used to simulate lens shifts
 	 */
 	void detemineStartPointOfFlap(float r[2], int flapNumber, float distance);
 
 	/**
 	 * \brief Determine if a coordinate is inside the bokeh image
 	 *
-	 * \param distance the distance that will be used. This parameter is modified a bit to mimic lens shifts
-	 * \param x the x coordinate of the pixel to evaluate
-	 * \param y the y coordinate of the pixel to evaluate
+	 * \param distance: the distance that will be used. This parameter is modified a bit to mimic lens shifts
+	 * \param x: the x coordinate of the pixel to evaluate
+	 * \param y: the y coordinate of the pixel to evaluate
 	 * \return float range 0..1 0 is completely outside
 	 */
 	float isInsideBokeh(float distance, float x, float y);
@@ -125,14 +125,14 @@ public:
 
 	/**
 	 * \brief determine the resolution of this operation. currently fixed at [COM_BLUR_BOKEH_PIXELS, COM_BLUR_BOKEH_PIXELS]
-	 * \param resolution
-	 * \param preferredResolution
+	 * \param resolution:
+	 * \param preferredResolution:
 	 */
 	void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
 	/**
 	 * \brief set the node data
-	 * \param data
+	 * \param data:
 	 */
 	void setData(NodeBokehImage *data) { this->m_data = data; }
 
diff --git a/source/blender/compositor/operations/COM_PixelateOperation.h b/source/blender/compositor/operations/COM_PixelateOperation.h
index cd91c2ccc05..381c723f7e8 100644
--- a/source/blender/compositor/operations/COM_PixelateOperation.h
+++ b/source/blender/compositor/operations/COM_PixelateOperation.h
@@ -41,7 +41,7 @@ private:
 public:
 	/**
 	 * \brief PixelateOperation
-	 * \param dataType the datatype to create this operator for (saves datatype conversions)
+	 * \param dataType: the datatype to create this operator for (saves datatype conversions)
 	 */
 	PixelateOperation(DataType dataType);
 
@@ -57,10 +57,10 @@ public:
 
 	/**
 	 * \brief executePixel
-	 * \param output result
-	 * \param x x-coordinate
-	 * \param y y-coordinate
-	 * \param sampler sampler
+	 * \param output: result
+	 * \param x: x-coordinate
+	 * \param y: y-coordinate
+	 * \param sampler: sampler
 	 */
 	void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
diff --git a/source/blender/compositor/operations/COM_SunBeamsOperation.cpp b/source/blender/compositor/operations/COM_SunBeamsOperation.cpp
index e556d366353..10d128d01c3 100644
--- a/source/blender/compositor/operations/COM_SunBeamsOperation.cpp
+++ b/source/blender/compositor/operations/COM_SunBeamsOperation.cpp
@@ -105,9 +105,9 @@ struct BufferLineAccumulator {
 	 * at dist_min from the target pt. This way the loop can be canceled as soon as it runs
 	 * out of the buffer rect, because no pixels further along the line can contribute.
 	 *
-	 * \param x, y  Start location in the buffer
-	 * \param num  Total steps in the loop
-	 * \param v, dv  Vertical offset in sector space, for line offset perpendicular to the loop axis
+	 * \param x, y: Start location in the buffer
+	 * \param num: Total steps in the loop
+	 * \param v, dv: Vertical offset in sector space, for line offset perpendicular to the loop axis
 	 */
 	static float *init_buffer_iterator(MemoryBuffer *input, const float source[2], const float co[2],
 	                                   float dist_min, float dist_max,