Cleanup: use colon separator after parameter

Helps separate variable names from descriptive text.
Was already used in some parts of the code,
double space and dashes were used elsewhere.

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,