COMPMID-556 Improved indentation and error handling in format_doxygen.py

Change-Id: I6f51ffe6c324d9da500716b52c97c344f2a2a164
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/110486
Tested-by: BSG Visual Compute Jenkins server to access repositories on http://mpd-gerrit.cambridge.arm.com <bsgcomp@arm.com>
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>

6 files changed, 154 insertions, 154 deletions

diff --git a/src/core/CL/cl_kernels/canny.cl b/src/core/CL/cl_kernels/canny.cl
index ec6719213c..166d681755 100644
--- a/src/core/CL/cl_kernels/canny.cl
+++ b/src/core/CL/cl_kernels/canny.cl
@@ -229,16 +229,16 @@ __kernel void suppress_non_maximum(
 #define hysteresis_local_stack_L2 16 // The size of level 2 stack, adjust this can impact the match rate with VX implementation
 
 /** Check whether pixel is valid
-*
-* Skip the pixel if the early_test fails.
-* Otherwise, it tries to add the pixel coordinate to the stack, and proceed to popping the stack instead if the stack is full
-*
-* @param[in] early_test Boolean condition based on the minv check and visited buffer check
-* @param[in] x_pos      X-coordinate of pixel that is going to be recorded, has to be within the boundary
-* @param[in] y_pos      Y-coordinate of pixel that is going to be recorded, has to be within the boundary
-* @param[in] x_cur      X-coordinate of current central pixel
-* @param[in] y_cur      Y-coordinate of current central pixel
-*/
+ *
+ * Skip the pixel if the early_test fails.
+ * Otherwise, it tries to add the pixel coordinate to the stack, and proceed to popping the stack instead if the stack is full
+ *
+ * @param[in] early_test Boolean condition based on the minv check and visited buffer check
+ * @param[in] x_pos      X-coordinate of pixel that is going to be recorded, has to be within the boundary
+ * @param[in] y_pos      Y-coordinate of pixel that is going to be recorded, has to be within the boundary
+ * @param[in] x_cur      X-coordinate of current central pixel
+ * @param[in] y_cur      Y-coordinate of current central pixel
+ */
 #define check_pixel(early_test, x_pos, y_pos, x_cur, y_cur)                               \
     {                                                                                     \
         if(!early_test)                                                                   \
diff --git a/src/core/CL/cl_kernels/depthwise_convolution.cl b/src/core/CL/cl_kernels/depthwise_convolution.cl
index 411e097dc8..89555a0cb6 100644
--- a/src/core/CL/cl_kernels/depthwise_convolution.cl
+++ b/src/core/CL/cl_kernels/depthwise_convolution.cl
@@ -145,36 +145,36 @@ inline float2 convolution3x3(
 }
 
 /** This function computes the horizontal integral of the image.
-  *
-  * @param[in] src_ptr                               Pointer to the source image. Supported data types: U8
-  * @param[in] src_stride_x                          Stride of the source image in X dimension (in bytes)
-  * @param[in] src_step_x                            src_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] src_stride_y                          Stride of the source image in Y dimension (in bytes)
-  * @param[in] src_step_y                            src_stride_y * number of elements along Y processed per workitem(in bytes)
-  * @param[in] src_offset_first_element_in_bytes     The offset of the first element in the source image
-  * @param[in] src_stride_z                          Stride of the source tensor in Z dimension (in bytes)
-  * @param[in] src_step_z                            src_stride_z * number of elements along Y processed per workitem(in bytes)
-  * @param[in] dst_ptr                               Pointer to the destination tensor. Supported data types: F16/F32
-  * @param[in] dst_stride_x                          Stride of the destination tensor in X dimension (in bytes)
-  * @param[in] dst_step_x                            dst_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] dst_stride_y                          Stride of the destination tensor in Y dimension (in bytes)
-  * @param[in] dst_step_y                            dst_stride_y * number of elements along Y processed per workitem(in bytes)
-  * @param[in] dst_stride_z                          Stride of the destination tensor in Z dimension (in bytes)
-  * @param[in] dst_step_z                            dst_stride_z * number of elements along Y processed per workitem(in bytes)
-  * @param[in] dst_offset_first_element_in_bytes     The offset of the first element in the destination tensor
-  * @param[in] weights_ptr                           Pointer to the weights tensor. Supported data types: F16/F32
-  * @param[in] weights_stride_x                      Stride of the weights tensor in X dimension (in bytes)
-  * @param[in] weights_step_x                        weights_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] weights_stride_y                      Stride of the weights tensor in Y dimension (in bytes)
-  * @param[in] weights_step_y                        weights_stride_y * number of elements along Y processed per workitem(in bytes)
-  * @param[in] weights_stride_z                      Stride of the weights tensor in Z dimension (in bytes)
-  * @param[in] weights_step_z                        weights_stride_z * number of elements along Y processed per workitem(in bytes)
-  * @param[in] weights_offset_first_element_in_bytes The offset of the first element in the biases vector
-  * @param[in] biases_ptr                            (Optional) Pointer to the biases vector. Supported data types: F16/F32
-  * @param[in] biases_stride_x                       (Optional) Stride of the biases vector in X dimension (in bytes)
-  * @param[in] biases_step_x                         (Optional) biases_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] biases_offset_first_element_in_bytes  (Optional) The offset of the first element in the biases vector
-  */
+ *
+ * @param[in] src_ptr                               Pointer to the source image. Supported data types: U8
+ * @param[in] src_stride_x                          Stride of the source image in X dimension (in bytes)
+ * @param[in] src_step_x                            src_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] src_stride_y                          Stride of the source image in Y dimension (in bytes)
+ * @param[in] src_step_y                            src_stride_y * number of elements along Y processed per workitem(in bytes)
+ * @param[in] src_offset_first_element_in_bytes     The offset of the first element in the source image
+ * @param[in] src_stride_z                          Stride of the source tensor in Z dimension (in bytes)
+ * @param[in] src_step_z                            src_stride_z * number of elements along Y processed per workitem(in bytes)
+ * @param[in] dst_ptr                               Pointer to the destination tensor. Supported data types: F16/F32
+ * @param[in] dst_stride_x                          Stride of the destination tensor in X dimension (in bytes)
+ * @param[in] dst_step_x                            dst_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] dst_stride_y                          Stride of the destination tensor in Y dimension (in bytes)
+ * @param[in] dst_step_y                            dst_stride_y * number of elements along Y processed per workitem(in bytes)
+ * @param[in] dst_stride_z                          Stride of the destination tensor in Z dimension (in bytes)
+ * @param[in] dst_step_z                            dst_stride_z * number of elements along Y processed per workitem(in bytes)
+ * @param[in] dst_offset_first_element_in_bytes     The offset of the first element in the destination tensor
+ * @param[in] weights_ptr                           Pointer to the weights tensor. Supported data types: F16/F32
+ * @param[in] weights_stride_x                      Stride of the weights tensor in X dimension (in bytes)
+ * @param[in] weights_step_x                        weights_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] weights_stride_y                      Stride of the weights tensor in Y dimension (in bytes)
+ * @param[in] weights_step_y                        weights_stride_y * number of elements along Y processed per workitem(in bytes)
+ * @param[in] weights_stride_z                      Stride of the weights tensor in Z dimension (in bytes)
+ * @param[in] weights_step_z                        weights_stride_z * number of elements along Y processed per workitem(in bytes)
+ * @param[in] weights_offset_first_element_in_bytes The offset of the first element in the biases vector
+ * @param[in] biases_ptr                            (Optional) Pointer to the biases vector. Supported data types: F16/F32
+ * @param[in] biases_stride_x                       (Optional) Stride of the biases vector in X dimension (in bytes)
+ * @param[in] biases_step_x                         (Optional) biases_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] biases_offset_first_element_in_bytes  (Optional) The offset of the first element in the biases vector
+ */
 
 __kernel void depthwise_convolution_3x3(
     TENSOR3D_DECLARATION(src),
diff --git a/src/core/CL/cl_kernels/depthwise_convolution_quantized.cl b/src/core/CL/cl_kernels/depthwise_convolution_quantized.cl
index 19a509bd0a..0cd4e7148e 100644
--- a/src/core/CL/cl_kernels/depthwise_convolution_quantized.cl
+++ b/src/core/CL/cl_kernels/depthwise_convolution_quantized.cl
@@ -176,41 +176,41 @@ inline uchar2 convolution3x3(
 }
 
 /** This function computes the horizontal integral of the image.
-  *
-  * @param[in] src_ptr                               Pointer to the source image. Supported data types: QASYMM8
-  * @param[in] src_stride_x                          Stride of the source image in X dimension (in bytes)
-  * @param[in] src_step_x                            src_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] src_stride_y                          Stride of the source image in Y dimension (in bytes)
-  * @param[in] src_step_y                            src_stride_y * number of elements along Y processed per workitem(in bytes)
-  * @param[in] src_offset_first_element_in_bytes     The offset of the first element in the source image
-  * @param[in] src_stride_z                          Stride of the source tensor in Z dimension (in bytes)
-  * @param[in] src_step_z                            src_stride_z * number of elements along Y processed per workitem(in bytes)
-  * @param[in] dst_ptr                               Pointer to the destination tensor. Supported data types: QASYMM8
-  * @param[in] dst_stride_x                          Stride of the destination tensor in X dimension (in bytes)
-  * @param[in] dst_step_x                            dst_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] dst_stride_y                          Stride of the destination tensor in Y dimension (in bytes)
-  * @param[in] dst_step_y                            dst_stride_y * number of elements along Y processed per workitem(in bytes)
-  * @param[in] dst_stride_z                          Stride of the destination tensor in Z dimension (in bytes)
-  * @param[in] dst_step_z                            dst_stride_z * number of elements along Y processed per workitem(in bytes)
-  * @param[in] dst_offset_first_element_in_bytes     The offset of the first element in the destination tensor
-  * @param[in] weights_ptr                           Pointer to the weights tensor. Supported data types: QASYMM8
-  * @param[in] weights_stride_x                      Stride of the weights tensor in X dimension (in bytes)
-  * @param[in] weights_step_x                        weights_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] weights_stride_y                      Stride of the weights tensor in Y dimension (in bytes)
-  * @param[in] weights_step_y                        weights_stride_y * number of elements along Y processed per workitem(in bytes)
-  * @param[in] weights_stride_z                      Stride of the weights tensor in Z dimension (in bytes)
-  * @param[in] weights_step_z                        weights_stride_z * number of elements along Y processed per workitem(in bytes)
-  * @param[in] weights_offset_first_element_in_bytes The offset of the first element in the weights tensor
-  * @param[in] biases_ptr                            (Optional) Pointer to the biases vector. Supported data types: QASYMM8
-  * @param[in] biases_stride_x                       (Optional) Stride of the biases vector in X dimension (in bytes)
-  * @param[in] biases_step_x                         (Optional) biases_stride_x * number of elements along X processed per workitem(in bytes)
-  * @param[in] biases_offset_first_element_in_bytes  (Optional) The offset of the first element in the biases vector
-  * @param[in] input_offset                          Quantized offset of zero point of the input tensor data range
-  * @param[in] weight_offset                         Quantized offset of zero point of the weights tensor data range
-  * @param[in] output_offset                         Quantized offset of zero point of the output tensor data range
-  * @param[in] output_multiplier                     Output scale multiplier
-  * @param[in] output_shift                          Output scale divisor exponent
-  */
+ *
+ * @param[in] src_ptr                               Pointer to the source image. Supported data types: QASYMM8
+ * @param[in] src_stride_x                          Stride of the source image in X dimension (in bytes)
+ * @param[in] src_step_x                            src_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] src_stride_y                          Stride of the source image in Y dimension (in bytes)
+ * @param[in] src_step_y                            src_stride_y * number of elements along Y processed per workitem(in bytes)
+ * @param[in] src_offset_first_element_in_bytes     The offset of the first element in the source image
+ * @param[in] src_stride_z                          Stride of the source tensor in Z dimension (in bytes)
+ * @param[in] src_step_z                            src_stride_z * number of elements along Y processed per workitem(in bytes)
+ * @param[in] dst_ptr                               Pointer to the destination tensor. Supported data types: QASYMM8
+ * @param[in] dst_stride_x                          Stride of the destination tensor in X dimension (in bytes)
+ * @param[in] dst_step_x                            dst_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] dst_stride_y                          Stride of the destination tensor in Y dimension (in bytes)
+ * @param[in] dst_step_y                            dst_stride_y * number of elements along Y processed per workitem(in bytes)
+ * @param[in] dst_stride_z                          Stride of the destination tensor in Z dimension (in bytes)
+ * @param[in] dst_step_z                            dst_stride_z * number of elements along Y processed per workitem(in bytes)
+ * @param[in] dst_offset_first_element_in_bytes     The offset of the first element in the destination tensor
+ * @param[in] weights_ptr                           Pointer to the weights tensor. Supported data types: QASYMM8
+ * @param[in] weights_stride_x                      Stride of the weights tensor in X dimension (in bytes)
+ * @param[in] weights_step_x                        weights_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] weights_stride_y                      Stride of the weights tensor in Y dimension (in bytes)
+ * @param[in] weights_step_y                        weights_stride_y * number of elements along Y processed per workitem(in bytes)
+ * @param[in] weights_stride_z                      Stride of the weights tensor in Z dimension (in bytes)
+ * @param[in] weights_step_z                        weights_stride_z * number of elements along Y processed per workitem(in bytes)
+ * @param[in] weights_offset_first_element_in_bytes The offset of the first element in the weights tensor
+ * @param[in] biases_ptr                            (Optional) Pointer to the biases vector. Supported data types: QASYMM8
+ * @param[in] biases_stride_x                       (Optional) Stride of the biases vector in X dimension (in bytes)
+ * @param[in] biases_step_x                         (Optional) biases_stride_x * number of elements along X processed per workitem(in bytes)
+ * @param[in] biases_offset_first_element_in_bytes  (Optional) The offset of the first element in the biases vector
+ * @param[in] input_offset                          Quantized offset of zero point of the input tensor data range
+ * @param[in] weight_offset                         Quantized offset of zero point of the weights tensor data range
+ * @param[in] output_offset                         Quantized offset of zero point of the output tensor data range
+ * @param[in] output_multiplier                     Output scale multiplier
+ * @param[in] output_shift                          Output scale divisor exponent
+ */
 
 __kernel void depthwise_convolution_3x3_quantized(
     TENSOR3D_DECLARATION(src),
diff --git a/src/core/CL/cl_kernels/fixed_point.h b/src/core/CL/cl_kernels/fixed_point.h
index b329118f14..d55346b532 100644
--- a/src/core/CL/cl_kernels/fixed_point.h
+++ b/src/core/CL/cl_kernels/fixed_point.h
@@ -103,11 +103,11 @@ TYPE_ALIAS(int, qs32)
 #define CONVERT_SAT(x, type) CONVERT_SAT_STR(x, type)
 
 /** Computes saturating absolute value of fixed point vector.
-  *
-  * @param[in] type the actual data type.
-  *
-  * @return The result of the fixed point absolute value.
-  */
+ *
+ * @param[in] type the actual data type.
+ *
+ * @return The result of the fixed point absolute value.
+ */
 #define ABSQ_SAT_IMPL(type)                  \
     inline type abs_##type##_sat(type VopA)  \
     {                                        \
@@ -121,11 +121,11 @@ ABSQ_SAT_IMPL(qs16x8)
 #define ABS_SAT_OP_EXPAND(a, type, size) ABS_SAT_OP_EXPAND_STR(a, type, size)
 
 /** Computes max of fixed point types.
-  *
-  * @param[in] type the actual data type.
-  *
-  * @return The result of the fixed point maximum.
-  */
+ *
+ * @param[in] type the actual data type.
+ *
+ * @return The result of the fixed point maximum.
+ */
 #define MAXQ_IMPL(type)                          \
     inline type max_##type(type VopA, type VopB) \
     {                                            \
@@ -147,11 +147,11 @@ MAXQ_IMPL(qs16x16)
 #define MAX_OP_EXPAND(a, b, type, size) MAX_OP_EXPAND_STR(a, b, type, size)
 
 /** Computes saturated addition of fixed point types.
-  *
-  * @param[in] type the actual data type.
-  *
-  * @return The result of the fixed point addition. The result is saturated in case of overflow
-  */
+ *
+ * @param[in] type the actual data type.
+ *
+ * @return The result of the fixed point addition. The result is saturated in case of overflow
+ */
 #define ADDQ_SAT_IMPL(type)                          \
     inline type add_sat_##type(type VopA, type VopB) \
     {                                                \
@@ -178,11 +178,11 @@ ADDQ_SAT_IMPL(qs32x16)
 #define ADD_SAT_OP_EXPAND(a, b, type, size) ADD_SAT_OP_EXPAND_STR(a, b, type, size)
 
 /** Computes saturated subtraction of fixed point types.
-  *
-  * @param[in] type the actual data type.
-  *
-  * @return The result of the fixed point subtraction. The result is saturated in case of overflow
-  */
+ *
+ * @param[in] type the actual data type.
+ *
+ * @return The result of the fixed point subtraction. The result is saturated in case of overflow
+ */
 #define SUBQ_SAT_IMPL(type)                          \
     inline type sub_sat_##type(type VopA, type VopB) \
     {                                                \
@@ -258,12 +258,12 @@ MULQ_SAT_IMPL(qs16x16, qs32x16)
 #define MUL_SAT_OP_EXPAND(a, b, type, size, position) MUL_SAT_OP_EXPAND_STR(a, b, type, size, position)
 
 /** Saturate multiply-accumulate
-  *
-  * @param[in] type  the actual data type.
-  * @param[in] itype the intermediate data type.
-  *
-  * @return The result of the fixed point multiply-accumulate. The result is saturated in case of overflow
-  */
+ *
+ * @param[in] type  the actual data type.
+ * @param[in] itype the intermediate data type.
+ *
+ * @return The result of the fixed point multiply-accumulate. The result is saturated in case of overflow
+ */
 #define MLAQ_SAT_IMPL(type, itype)                                                                                 \
     type mla_sat_##type(type VopA, type VopB, type VopC, int fixed_point_position)                                 \
     {                                                                                                              \
@@ -279,12 +279,12 @@ MLAQ_SAT_IMPL(qs16x8, qs32x8)
 #define MLA_SAT_OP_EXPAND(a, b, c, type, size, position) MLA_SAT_OP_EXPAND_STR(a, b, c, type, size, position)
 
 /** Saturate multiply-accumulate long
-  *
-  * @param[in] type  the actual data type.
-  * @param[in] itype the intermediate data type.
-  *
-  * @return The result of the fixed point multiply-accumulate long. The result is saturated in case of overflow
-  */
+ *
+ * @param[in] type  the actual data type.
+ * @param[in] itype the intermediate data type.
+ *
+ * @return The result of the fixed point multiply-accumulate long. The result is saturated in case of overflow
+ */
 #define MLALQ_SAT_IMPL(type, itype)                                                                                \
     itype mlal_sat_##type(itype VopA, type VopB, type VopC, int fixed_point_position)                              \
     {                                                                                                              \
@@ -299,13 +299,13 @@ MLALQ_SAT_IMPL(qs16x8, qs32x8)
 #define MLAL_SAT_OP_EXPAND(a, b, c, type, size, position) MLAL_SAT_OP_EXPAND_STR(a, b, c, type, size, position)
 
 /** Saturate division of two fixed point vectors
-  *
-  * @param[in] stype the actual scalar data type.
-  * @param[in] type  the actual data type.
-  * @param[in] itype the intermediate data type.
-  *
-  * @return The result of the fixed point division. The result is saturated in case of overflow
-  */
+ *
+ * @param[in] stype the actual scalar data type.
+ * @param[in] type  the actual data type.
+ * @param[in] itype the intermediate data type.
+ *
+ * @return The result of the fixed point division. The result is saturated in case of overflow
+ */
 #define DIVQ_SAT_IMPL(stype, type, itype)                                                                                                                                           \
     inline type div_sat_##type(type VopA, type VopB, int fixed_point_position)                                                                                                      \
     {                                                                                                                                                                               \
@@ -329,15 +329,15 @@ DIVQ_SAT_IMPL(qs16, qs16, qs32)
 #define DIV_SAT_OP_VEC_EXPAND(a, b, type, size, position) DIV_SAT_OP_VEC_EXPAND_STR(a, b, type, size, position)
 
 /** Saturate exponential of a fixed point vector
-  *
-  * @note Implemented approach uses taylor polynomial to approximate the exponential function.
-  *
-  * @param[in] stype the actual scalar data type.
-  * @param[in] type  the actual data type.
-  * @param[in] size  the number of the calculated elements.
-  *
-  * @return The result of the fixed point exponential. The result is saturated in case of overflow
-  */
+ *
+ * @note Implemented approach uses taylor polynomial to approximate the exponential function.
+ *
+ * @param[in] stype the actual scalar data type.
+ * @param[in] type  the actual data type.
+ * @param[in] size  the number of the calculated elements.
+ *
+ * @return The result of the fixed point exponential. The result is saturated in case of overflow
+ */
 #define EXPQ_IMPL(stype, type, size)                                                                                                              \
     inline type exp_sat_##type(type VopA, int fixed_point_position)                                                                               \
     {                                                                                                                                             \
@@ -372,15 +372,15 @@ EXPQ_IMPL(qs16, qs16x16, 16)
 #define EXP_OP_EXPAND(a, type, size, position) EXP_OP_EXPAND_STR(a, type, size, position)
 
 /** Saturate logarithm of a fixed point vector
-  *
-  * @note Implemented approach uses taylor polynomial to approximate the logarithm function.
-  *
-  * @param[in] stype the actual scalar data type.
-  * @param[in] type  the actual data type.
-  * @param[in] size  the number of the calculated elements.
-  *
-  * @return The result of the fixed point logarithm. The result is saturated in case of overflow
-  */
+ *
+ * @note Implemented approach uses taylor polynomial to approximate the logarithm function.
+ *
+ * @param[in] stype the actual scalar data type.
+ * @param[in] type  the actual data type.
+ * @param[in] size  the number of the calculated elements.
+ *
+ * @return The result of the fixed point logarithm. The result is saturated in case of overflow
+ */
 #define LOGQ_IMPL(stype, type, size)                                                                                                       \
     inline type log_sat_##type(type VopA, int fixed_point_position)                                                                        \
     {                                                                                                                                      \
@@ -410,15 +410,15 @@ LOGQ_IMPL(qs16, qs16x16, 16)
 #define LOG_OP_EXPAND(a, type, size, position) LOG_OP_EXPAND_STR(a, type, size, position)
 
 /** Saturate inverse square root of a fixed point vector
-  *
-  * @note Implemented approach uses Newton's method to approximate the inverse square root function.
-  *
-  * @param[in] stype the actual scalar data type.
-  * @param[in] type  the actual data type.
-  * @param[in] size  the number of the calculated elements.
-  *
-  * @return The result of the fixed point inverse square root. The result is saturated in case of overflow
-  */
+ *
+ * @note Implemented approach uses Newton's method to approximate the inverse square root function.
+ *
+ * @param[in] stype the actual scalar data type.
+ * @param[in] type  the actual data type.
+ * @param[in] size  the number of the calculated elements.
+ *
+ * @return The result of the fixed point inverse square root. The result is saturated in case of overflow
+ */
 #define INVSQRTQ_IMPL(stype, type, size)                                                                                                                                                                                               \
     inline type invsqrt_sat_##type(type VopA, int fixed_point_position)                                                                                                                                                                \
     {                                                                                                                                                                                                                                  \
@@ -447,15 +447,15 @@ INVSQRTQ_IMPL(qs16, qs16x8, 8)
 #define INVSQRT_OP_EXPAND(a, type, size, position) INVSQRT_OP_EXPAND_STR(a, type, size, position)
 
 /** Saturate hyperbolic tangent of a fixed point vector
-  *
-  * tanh(x) = (e^2x - 1)/(e^2x + 1)
-  *
-  * @param[in] stype the actual scalar data type.
-  * @param[in] type  the actual data type.
-  * @param[in] size  the number of the calculated elements.
-  *
-  * @return The result of the fixed point hyperbolic tangent. The result is saturated in case of overflow
-  */
+ *
+ * tanh(x) = (e^2x - 1)/(e^2x + 1)
+ *
+ * @param[in] stype the actual scalar data type.
+ * @param[in] type  the actual data type.
+ * @param[in] size  the number of the calculated elements.
+ *
+ * @return The result of the fixed point hyperbolic tangent. The result is saturated in case of overflow
+ */
 #define TANHQ_IMPL(stype, type, size)                                                                                                             \
     inline type tanh_sat_##type(type VopA, int fixed_point_position)                                                                              \
     {                                                                                                                                             \
diff --git a/src/core/CL/cl_kernels/warp_helpers.h b/src/core/CL/cl_kernels/warp_helpers.h
index 76f0a4a104..9afec7d081 100644
--- a/src/core/CL/cl_kernels/warp_helpers.h
+++ b/src/core/CL/cl_kernels/warp_helpers.h
@@ -78,7 +78,7 @@ inline const float2 get_current_coords()
  * @param[in] coord Input coordinates
  *
  * @return vector of 8 floats with the coordinates, even positions are x and odd y.
-*/
+ */
 inline const float8 get_neighbour_coords(const float2 coord)
 {
     return (float8)(/*tl*/ coord.s0, coord.s1, /*tr*/ coord.s0 + 1, coord.s1, /*bl*/ coord.s0, coord.s1 + 1, /*br*/ coord.s0 + 1, coord.s1 + 1);
@@ -91,7 +91,7 @@ inline const float8 get_neighbour_coords(const float2 coord)
  * @param[in] width       Width of the image
  * @param[in] height      Height of the image
  * @param[in] border_size Border size
-*/
+ */
 inline const VEC_DATA_TYPE(DATA_TYPE, 4) bilinear_interpolate_with_border(const Image *in, const float8 coords, const float width, const float height, const float border_size)
 {
     // If any of the 4 texels is out of the image's boundaries we use the border value (REPLICATE or CONSTANT) for any texel out of the image.
@@ -133,7 +133,7 @@ inline const VEC_DATA_TYPE(DATA_TYPE, 4) bilinear_interpolate_with_border(const
  * @param[in] coords Vector of four 2D coordinates. Even pos is x and odd y.
  * @param[in] width  Width of the image
  * @param[in] height Height of the image
-*/
+ */
 inline const VEC_DATA_TYPE(DATA_TYPE, 4) bilinear_interpolate(const Image *in, const float8 coords, const float width, const float height)
 {
     return bilinear_interpolate_with_border(in, coords, width, height, 1);
diff --git a/src/core/CL/cl_kernels/warp_perspective.cl b/src/core/CL/cl_kernels/warp_perspective.cl
index d955e427c4..6ffb7e4a00 100644
--- a/src/core/CL/cl_kernels/warp_perspective.cl
+++ b/src/core/CL/cl_kernels/warp_perspective.cl
@@ -62,7 +62,7 @@ inline const float8 apply_perspective_transform(const float2 coord, const float1
  *   x0 = M[1][1] * x + M[1][2] * y + M[1][3]
  *   y0 = M[2][1] * x + M[2][2] * y + M[2][3]
  *   z0 = M[3][1] * x + M[3][2] * y + M[3][3]
-
+ *
  *   output(x,y) = input(x0/z0,y0/z0)
  *
  * @attention The matrix coefficients need to be passed at compile time:\n