diff --git a/src/ustreamer/encoder.c b/src/ustreamer/encoder.c
index cd96ec0..88b7593 100644
--- a/src/ustreamer/encoder.c
+++ b/src/ustreamer/encoder.c
@@ -36,7 +36,7 @@ static const struct {
 };
 
 
-#define ER(_next)	encoder->run->_next
+#define ER(_next)	enc->run->_next
 #define DR(_next)	dev->run->_next
 
 
@@ -47,15 +47,15 @@ encoder_s *encoder_init(void) {
 	run->quality = 80;
 	A_MUTEX_INIT(&run->mutex);
 
-	encoder_s *encoder;
-	A_CALLOC(encoder, 1);
-	encoder->type = run->type;
-	encoder->n_workers = get_cores_available();
-	encoder->run = run;
-	return encoder;
+	encoder_s *enc;
+	A_CALLOC(enc, 1);
+	enc->type = run->type;
+	enc->n_workers = get_cores_available();
+	enc->run = run;
+	return enc;
 }
 
-void encoder_destroy(encoder_s *encoder) {
+void encoder_destroy(encoder_s *enc) {
 #	ifdef WITH_OMX
 	if (ER(omxs)) {
 		for (unsigned index = 0; index < ER(n_omxs); ++index) {
@@ -67,8 +67,8 @@ void encoder_destroy(encoder_s *encoder) {
 	}
 #	endif
 	A_MUTEX_DESTROY(&ER(mutex));
-	free(encoder->run);
-	free(encoder);
+	free(enc->run);
+	free(enc);
 }
 
 encoder_type_e encoder_parse_type(const char *str) {
@@ -89,12 +89,12 @@ const char *encoder_type_to_string(encoder_type_e type) {
 	return _ENCODER_TYPES[0].name;
 }
 
-void encoder_prepare(encoder_s *encoder, device_s *dev) {
-	encoder_type_e type = (ER(cpu_forced) ? ENCODER_TYPE_CPU : encoder->type);
+void encoder_prepare(encoder_s *enc, device_s *dev) {
+	encoder_type_e type = (ER(cpu_forced) ? ENCODER_TYPE_CPU : enc->type);
 	unsigned quality = dev->jpeg_quality;
 	bool cpu_forced = false;
 
-	ER(n_workers) = min_u(encoder->n_workers, DR(n_buffers));
+	ER(n_workers) = min_u(enc->n_workers, DR(n_buffers));
 
 	if ((DR(format) == V4L2_PIX_FMT_MJPEG || DR(format) == V4L2_PIX_FMT_JPEG) && type != ENCODER_TYPE_HW) {
 		LOG_INFO("Switching to HW encoder because the input format is (M)JPEG");
@@ -111,10 +111,10 @@ void encoder_prepare(encoder_s *encoder, device_s *dev) {
 	}
 #	ifdef WITH_OMX
 	else if (type == ENCODER_TYPE_OMX) {
-		for (unsigned index = 0; index < encoder->n_glitched_resolutions; ++index) {
+		for (unsigned index = 0; index < enc->n_glitched_resolutions; ++index) {
 			if (
-				encoder->glitched_resolutions[index][0] == DR(width)
-				&& encoder->glitched_resolutions[index][1] == DR(height)
+				enc->glitched_resolutions[index][0] == DR(width)
+				&& enc->glitched_resolutions[index][1] == DR(height)
 			) {
 				LOG_INFO("Switching to CPU encoder the resolution %ux%u marked as glitchy for OMX",
 					DR(width), DR(height));
@@ -185,7 +185,7 @@ void encoder_prepare(encoder_s *encoder, device_s *dev) {
 		A_MUTEX_UNLOCK(&ER(mutex));
 }
 
-void encoder_get_runtime_params(encoder_s *encoder, encoder_type_e *type, unsigned *quality) {
+void encoder_get_runtime_params(encoder_s *enc, encoder_type_e *type, unsigned *quality) {
 	A_MUTEX_LOCK(&ER(mutex));
 	*type = ER(type);
 	*quality = ER(quality);
@@ -194,7 +194,7 @@ void encoder_get_runtime_params(encoder_s *encoder, encoder_type_e *type, unsign
 
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic push
-int encoder_compress(encoder_s *encoder, unsigned worker_number, frame_s *src, frame_s *dest) {
+int encoder_compress(encoder_s *enc, unsigned worker_number, frame_s *src, frame_s *dest) {
 #pragma GCC diagnostic pop
 
 	assert(ER(type) != ENCODER_TYPE_UNKNOWN);
diff --git a/src/ustreamer/encoder.h b/src/ustreamer/encoder.h
index bdf8830..37e3aa3 100644
--- a/src/ustreamer/encoder.h
+++ b/src/ustreamer/encoder.h
@@ -76,7 +76,7 @@ typedef struct {
 	unsigned n_workers;
 
 #	ifdef WITH_OMX
-	unsigned				n_omxs;
+	unsigned		n_omxs;
 	omx_encoder_s	**omxs;
 #	endif
 } encoder_runtime_s;
@@ -94,12 +94,12 @@ typedef struct {
 
 
 encoder_s *encoder_init(void);
-void encoder_destroy(encoder_s *encoder);
+void encoder_destroy(encoder_s *enc);
 
 encoder_type_e encoder_parse_type(const char *str);
 const char *encoder_type_to_string(encoder_type_e type);
 
-void encoder_prepare(encoder_s *encoder, device_s *dev);
-void encoder_get_runtime_params(encoder_s *encoder, encoder_type_e *type, unsigned *quality);
+void encoder_prepare(encoder_s *enc, device_s *dev);
+void encoder_get_runtime_params(encoder_s *enc, encoder_type_e *type, unsigned *quality);
 
-int encoder_compress(encoder_s *encoder, unsigned worker_number, frame_s *src, frame_s *dest);
+int encoder_compress(encoder_s *enc, unsigned worker_number, frame_s *src, frame_s *dest);
diff --git a/src/ustreamer/encoders/omx/component.c b/src/ustreamer/encoders/omx/component.c
index bd4282c..dd5fb53 100644
--- a/src/ustreamer/encoders/omx/component.c
+++ b/src/ustreamer/encoders/omx/component.c
@@ -23,33 +23,33 @@
 #include "component.h"
 
 
-static int _omx_component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled);
-static int _omx_component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYPE wanted);
+static int _omx_component_wait_port_changed(OMX_HANDLETYPE *comp, OMX_U32 port, OMX_BOOL enabled);
+static int _omx_component_wait_state_changed(OMX_HANDLETYPE *comp, OMX_STATETYPE wanted);
 
 
-int omx_component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
+int omx_component_enable_port(OMX_HANDLETYPE *comp, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
 	LOG_DEBUG("Enabling OMX port %u ...", port);
-	if ((error = OMX_SendCommand(*component, OMX_CommandPortEnable, port, NULL)) != OMX_ErrorNone) {
+	if ((error = OMX_SendCommand(*comp, OMX_CommandPortEnable, port, NULL)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't enable OMX port %u", port);
 		return -1;
 	}
-	return _omx_component_wait_port_changed(component, port, OMX_TRUE);
+	return _omx_component_wait_port_changed(comp, port, OMX_TRUE);
 }
 
-int omx_component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
+int omx_component_disable_port(OMX_HANDLETYPE *comp, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
 	LOG_DEBUG("Disabling OMX port %u ...", port);
-	if ((error = OMX_SendCommand(*component, OMX_CommandPortDisable, port, NULL)) != OMX_ErrorNone) {
+	if ((error = OMX_SendCommand(*comp, OMX_CommandPortDisable, port, NULL)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't disable OMX port %u", port);
 		return -1;
 	}
-	return _omx_component_wait_port_changed(component, port, OMX_FALSE);
+	return _omx_component_wait_port_changed(comp, port, OMX_FALSE);
 }
 
-int omx_component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port) {
+int omx_component_get_portdef(OMX_HANDLETYPE *comp, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
 	// cppcheck-suppress redundantPointerOp
@@ -57,25 +57,25 @@ int omx_component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIO
 	portdef->nPortIndex = port;
 
 	LOG_DEBUG("Fetching OMX port %u definition ...", port);
-	if ((error = OMX_GetParameter(*component, OMX_IndexParamPortDefinition, portdef)) != OMX_ErrorNone) {
+	if ((error = OMX_GetParameter(*comp, OMX_IndexParamPortDefinition, portdef)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't get OMX port %u definition", port);
 		return -1;
 	}
 	return 0;
 }
 
-int omx_component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef) {
+int omx_component_set_portdef(OMX_HANDLETYPE *comp, OMX_PARAM_PORTDEFINITIONTYPE *portdef) {
 	OMX_ERRORTYPE error;
 
 	LOG_DEBUG("Writing OMX port %u definition ...", portdef->nPortIndex);
-	if ((error = OMX_SetParameter(*component, OMX_IndexParamPortDefinition, portdef)) != OMX_ErrorNone) {
+	if ((error = OMX_SetParameter(*comp, OMX_IndexParamPortDefinition, portdef)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't set OMX port %u definition", portdef->nPortIndex);
 		return -1;
 	}
 	return 0;
 }
 
-int omx_component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
+int omx_component_set_state(OMX_HANDLETYPE *comp, OMX_STATETYPE state) {
 	const char *state_str = omx_state_to_string(state);
 	OMX_ERRORTYPE error;
 
@@ -83,9 +83,9 @@ int omx_component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
 
 	int retries = 50;
 	do {
-		error = OMX_SendCommand(*component, OMX_CommandStateSet, state, NULL);
+		error = OMX_SendCommand(*comp, OMX_CommandStateSet, state, NULL);
 		if (error == OMX_ErrorNone) {
-			return _omx_component_wait_state_changed(component, state);
+			return _omx_component_wait_state_changed(comp, state);
 		} else if (error == OMX_ErrorInsufficientResources && retries) {
 			// Иногда железо не инициализируется, хз почему, просто ретраим, со второй попытки сработает
 			LOG_ERROR_OMX(error, "Can't switch OMX component state to %s, need to retry", state_str);
@@ -101,7 +101,7 @@ int omx_component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
 }
 
 
-static int _omx_component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled) {
+static int _omx_component_wait_port_changed(OMX_HANDLETYPE *comp, OMX_U32 port, OMX_BOOL enabled) {
 	OMX_ERRORTYPE error;
 
 	OMX_PARAM_PORTDEFINITIONTYPE portdef;
@@ -110,7 +110,7 @@ static int _omx_component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 p
 
 	int retries = 50;
 	do {
-		if ((error = OMX_GetParameter(*component, OMX_IndexParamPortDefinition, &portdef)) != OMX_ErrorNone) {
+		if ((error = OMX_GetParameter(*comp, OMX_IndexParamPortDefinition, &portdef)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't get OMX port %u definition for waiting", port);
 			return -1;
 		}
@@ -126,13 +126,13 @@ static int _omx_component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 p
 	return (portdef.bEnabled == enabled ? 0 : -1);
 }
 
-static int _omx_component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYPE wanted) {
+static int _omx_component_wait_state_changed(OMX_HANDLETYPE *comp, OMX_STATETYPE wanted) {
 	OMX_ERRORTYPE error;
 	OMX_STATETYPE state;
 
 	int retries = 50;
 	do {
-		if ((error = OMX_GetState(*component, &state)) != OMX_ErrorNone) {
+		if ((error = OMX_GetState(*comp, &state)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Failed to get OMX component state");
 			return -1;
 		}
diff --git a/src/ustreamer/encoders/omx/component.h b/src/ustreamer/encoders/omx/component.h
index 2bdfa8b..a55878a 100644
--- a/src/ustreamer/encoders/omx/component.h
+++ b/src/ustreamer/encoders/omx/component.h
@@ -44,10 +44,10 @@
 	}
 
 
-int omx_component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port);
-int omx_component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port);
+int omx_component_enable_port(OMX_HANDLETYPE *comp, OMX_U32 port);
+int omx_component_disable_port(OMX_HANDLETYPE *comp, OMX_U32 port);
 
-int omx_component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port);
-int omx_component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef);
+int omx_component_get_portdef(OMX_HANDLETYPE *comp, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port);
+int omx_component_set_portdef(OMX_HANDLETYPE *comp, OMX_PARAM_PORTDEFINITIONTYPE *portdef);
 
-int omx_component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state);
+int omx_component_set_state(OMX_HANDLETYPE *comp, OMX_STATETYPE state);
diff --git a/src/ustreamer/encoders/omx/encoder.c b/src/ustreamer/encoders/omx/encoder.c
index 5ac2aa8..e35edc4 100644
--- a/src/ustreamer/encoders/omx/encoder.c
+++ b/src/ustreamer/encoders/omx/encoder.c
@@ -35,16 +35,16 @@ static int _omx_setup_output(omx_encoder_s *omx, unsigned quality);
 static int _omx_encoder_clear_ports(omx_encoder_s *omx);
 
 static OMX_ERRORTYPE _omx_event_handler(
-	UNUSED OMX_HANDLETYPE encoder,
+	UNUSED OMX_HANDLETYPE comp,
 	OMX_PTR v_omx, OMX_EVENTTYPE event, OMX_U32 data1,
 	UNUSED OMX_U32 data2, UNUSED OMX_PTR event_data);
 
 static OMX_ERRORTYPE _omx_input_required_handler(
-	UNUSED OMX_HANDLETYPE encoder,
+	UNUSED OMX_HANDLETYPE comp,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
 
 static OMX_ERRORTYPE _omx_output_available_handler(
-	UNUSED OMX_HANDLETYPE encoder,
+	UNUSED OMX_HANDLETYPE comp,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
 
 
@@ -88,9 +88,9 @@ omx_encoder_s *omx_encoder_init(void) {
 void omx_encoder_destroy(omx_encoder_s *omx) {
 	LOG_INFO("Destroying OMX encoder ...");
 
-	omx_component_set_state(&omx->encoder, OMX_StateIdle);
+	omx_component_set_state(&omx->comp, OMX_StateIdle);
 	_omx_encoder_clear_ports(omx);
-	omx_component_set_state(&omx->encoder, OMX_StateLoaded);
+	omx_component_set_state(&omx->comp, OMX_StateLoaded);
 
 	if (omx->i_handler_sem) {
 		vcos_semaphore_delete(&omx->handler_sem);
@@ -98,7 +98,7 @@ void omx_encoder_destroy(omx_encoder_s *omx) {
 
 	if (omx->i_encoder) {
 		OMX_ERRORTYPE error;
-		if ((error = OMX_FreeHandle(omx->encoder)) != OMX_ErrorNone) {
+		if ((error = OMX_FreeHandle(omx->comp)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't free OMX.broadcom.image_encode");
 		}
 	}
@@ -107,7 +107,7 @@ void omx_encoder_destroy(omx_encoder_s *omx) {
 }
 
 int omx_encoder_prepare(omx_encoder_s *omx, device_s *dev, unsigned quality) {
-	if (omx_component_set_state(&omx->encoder, OMX_StateIdle) < 0) {
+	if (omx_component_set_state(&omx->comp, OMX_StateIdle) < 0) {
 		return -1;
 	}
 	if (_omx_encoder_clear_ports(omx) < 0) {
@@ -119,7 +119,7 @@ int omx_encoder_prepare(omx_encoder_s *omx, device_s *dev, unsigned quality) {
 	if (_omx_setup_output(omx, quality) < 0) {
 		return -1;
 	}
-	if (omx_component_set_state(&omx->encoder, OMX_StateExecuting) < 0) {
+	if (omx_component_set_state(&omx->comp, OMX_StateExecuting) < 0) {
 		return -1;
 	}
 	return 0;
@@ -131,7 +131,7 @@ int omx_encoder_compress(omx_encoder_s *omx, const frame_s *src, frame_s *dest)
 
 	OMX_ERRORTYPE error;
 
-	if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) {
+	if ((error = OMX_FillThisBuffer(omx->comp, omx->output_buffer)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Failed to request filling of the output buffer on encoder");
 		return -1;
 	}
@@ -158,7 +158,7 @@ int omx_encoder_compress(omx_encoder_s *omx, const frame_s *src, frame_s *dest)
 				break;
 			}
 
-			if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) {
+			if ((error = OMX_FillThisBuffer(omx->comp, omx->output_buffer)) != OMX_ErrorNone) {
 				LOG_ERROR_OMX(error, "Failed to request filling of the output buffer on encoder");
 				return -1;
 			}
@@ -181,7 +181,7 @@ int omx_encoder_compress(omx_encoder_s *omx, const frame_s *src, frame_s *dest)
 				slice_size = src->used - pos;
 			}
 
-			if ((error = OMX_EmptyThisBuffer(omx->encoder, omx->input_buffer)) != OMX_ErrorNone) {
+			if ((error = OMX_EmptyThisBuffer(omx->comp, omx->input_buffer)) != OMX_ErrorNone) {
 				LOG_ERROR_OMX(error, "Failed to request emptying of the input buffer on encoder");
 				return -1;
 			}
@@ -241,7 +241,7 @@ static int _omx_init_component(omx_encoder_s *omx) {
 	callbacks.FillBufferDone = _omx_output_available_handler;
 
 	LOG_DEBUG("Initializing OMX.broadcom.image_encode ...");
-	if ((error = OMX_GetHandle(&omx->encoder, "OMX.broadcom.image_encode", omx, &callbacks)) != OMX_ErrorNone) {
+	if ((error = OMX_GetHandle(&omx->comp, "OMX.broadcom.image_encode", omx, &callbacks)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't initialize OMX.broadcom.image_encode");
 		return -1;
 	}
@@ -258,18 +258,18 @@ static int _omx_init_disable_ports(omx_encoder_s *omx) {
 	OMX_PORT_PARAM_TYPE ports;
 
 	OMX_INIT_STRUCTURE(ports);
-	if ((error = OMX_GetParameter(omx->encoder, OMX_IndexParamImageInit, &ports)) != OMX_ErrorNone) {
+	if ((error = OMX_GetParameter(omx->comp, OMX_IndexParamImageInit, &ports)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't OMX_GetParameter(OMX_IndexParamImageInit)");
 		return -1;
 	}
 
 	for (unsigned index = 0; index < 4; ++index) {
-		if ((error = OMX_GetParameter(omx->encoder, types[index], &ports)) != OMX_ErrorNone) {
+		if ((error = OMX_GetParameter(omx->comp, types[index], &ports)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't OMX_GetParameter(types[%u])", index);
 			return -1;
 		}
 		for (OMX_U32 port = ports.nStartPortNumber; port < ports.nStartPortNumber + ports.nPorts; ++port) {
-			if (omx_component_disable_port(&omx->encoder, port) < 0) {
+			if (omx_component_disable_port(&omx->comp, port) < 0) {
 				return -1;
 			}
 		}
@@ -283,7 +283,7 @@ static int _omx_setup_input(omx_encoder_s *omx, device_s *dev) {
 	OMX_ERRORTYPE error;
 	OMX_PARAM_PORTDEFINITIONTYPE portdef;
 
-	if (omx_component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
+	if (omx_component_get_portdef(&omx->comp, &portdef, _INPUT_PORT) < 0) {
 		LOG_ERROR("... first");
 		return -1;
 	}
@@ -311,21 +311,21 @@ static int _omx_setup_input(omx_encoder_s *omx, device_s *dev) {
 	}
 #	undef IFMT
 
-	if (omx_component_set_portdef(&omx->encoder, &portdef) < 0) {
+	if (omx_component_set_portdef(&omx->comp, &portdef) < 0) {
 		return -1;
 	}
 
-	if (omx_component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
+	if (omx_component_get_portdef(&omx->comp, &portdef, _INPUT_PORT) < 0) {
 		LOG_ERROR("... second");
 		return -1;
 	}
 
-	if (omx_component_enable_port(&omx->encoder, _INPUT_PORT) < 0) {
+	if (omx_component_enable_port(&omx->comp, _INPUT_PORT) < 0) {
 		return -1;
 	}
 	omx->i_input_port_enabled = true;
 
-	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->input_buffer, _INPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
+	if ((error = OMX_AllocateBuffer(omx->comp, &omx->input_buffer, _INPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't allocate OMX JPEG input buffer");
 		return -1;
 	}
@@ -338,7 +338,7 @@ static int _omx_setup_output(omx_encoder_s *omx, unsigned quality) {
 	OMX_ERRORTYPE error;
 	OMX_PARAM_PORTDEFINITIONTYPE portdef;
 
-	if (omx_component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
+	if (omx_component_get_portdef(&omx->comp, &portdef, _OUTPUT_PORT) < 0) {
 		LOG_ERROR("... first");
 		return -1;
 	}
@@ -349,11 +349,11 @@ static int _omx_setup_output(omx_encoder_s *omx, unsigned quality) {
 	OFMT(eColorFormat) = OMX_COLOR_FormatYCbYCr;
 #	undef OFMT
 
-	if (omx_component_set_portdef(&omx->encoder, &portdef) < 0) {
+	if (omx_component_set_portdef(&omx->comp, &portdef) < 0) {
 		return -1;
 	}
 
-	if (omx_component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
+	if (omx_component_get_portdef(&omx->comp, &portdef, _OUTPUT_PORT) < 0) {
 		LOG_ERROR("... second");
 		return -1;
 	}
@@ -364,7 +364,7 @@ static int _omx_setup_output(omx_encoder_s *omx, unsigned quality) {
 		OMX_INIT_STRUCTURE(exif);
 		exif.bEnabled = OMX_FALSE;
 
-		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamBrcmDisableEXIF, &exif)) != OMX_ErrorNone) {
+		if ((error = OMX_SetParameter(omx->comp, OMX_IndexParamBrcmDisableEXIF, &exif)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't disable EXIF on OMX JPEG");
 			return -1;
 		}
@@ -377,7 +377,7 @@ static int _omx_setup_output(omx_encoder_s *omx, unsigned quality) {
 		ijg.nPortIndex = _OUTPUT_PORT;
 		ijg.bEnabled = OMX_TRUE;
 
-		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamBrcmEnableIJGTableScaling, &ijg)) != OMX_ErrorNone) {
+		if ((error = OMX_SetParameter(omx->comp, OMX_IndexParamBrcmEnableIJGTableScaling, &ijg)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't set OMX JPEG IJG settings");
 			return -1;
 		}
@@ -390,18 +390,18 @@ static int _omx_setup_output(omx_encoder_s *omx, unsigned quality) {
 		qfactor.nPortIndex = _OUTPUT_PORT;
 		qfactor.nQFactor = quality;
 
-		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamQFactor, &qfactor)) != OMX_ErrorNone) {
+		if ((error = OMX_SetParameter(omx->comp, OMX_IndexParamQFactor, &qfactor)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't set OMX JPEG quality");
 			return -1;
 		}
 	}
 
-	if (omx_component_enable_port(&omx->encoder, _OUTPUT_PORT) < 0) {
+	if (omx_component_enable_port(&omx->comp, _OUTPUT_PORT) < 0) {
 		return -1;
 	}
 	omx->i_output_port_enabled = true;
 
-	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->output_buffer, _OUTPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
+	if ((error = OMX_AllocateBuffer(omx->comp, &omx->output_buffer, _OUTPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
 		LOG_ERROR_OMX(error, "Can't allocate OMX JPEG output buffer");
 		return -1;
 	}
@@ -413,23 +413,23 @@ static int _omx_encoder_clear_ports(omx_encoder_s *omx) {
 	int retval = 0;
 
 	if (omx->i_output_port_enabled) {
-		retval -= omx_component_disable_port(&omx->encoder, _OUTPUT_PORT);
+		retval -= omx_component_disable_port(&omx->comp, _OUTPUT_PORT);
 		omx->i_output_port_enabled = false;
 	}
 	if (omx->i_input_port_enabled) {
-		retval -= omx_component_disable_port(&omx->encoder, _INPUT_PORT);
+		retval -= omx_component_disable_port(&omx->comp, _INPUT_PORT);
 		omx->i_input_port_enabled = false;
 	}
 
 	if (omx->input_buffer) {
-		if ((error = OMX_FreeBuffer(omx->encoder, _INPUT_PORT, omx->input_buffer)) != OMX_ErrorNone) {
+		if ((error = OMX_FreeBuffer(omx->comp, _INPUT_PORT, omx->input_buffer)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't free OMX JPEG input buffer");
 			// retval -= 1;
 		}
 		omx->input_buffer = NULL;
 	}
 	if (omx->output_buffer) {
-		if ((error = OMX_FreeBuffer(omx->encoder, _OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
+		if ((error = OMX_FreeBuffer(omx->comp, _OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't free OMX JPEG output buffer");
 			// retval -= 1;
 		}
@@ -439,7 +439,7 @@ static int _omx_encoder_clear_ports(omx_encoder_s *omx) {
 }
 
 static OMX_ERRORTYPE _omx_event_handler(
-	UNUSED OMX_HANDLETYPE encoder,
+	UNUSED OMX_HANDLETYPE comp,
 	OMX_PTR v_omx, OMX_EVENTTYPE event, OMX_U32 data1,
 	UNUSED OMX_U32 data2, UNUSED OMX_PTR event_data) {
 
@@ -456,7 +456,7 @@ static OMX_ERRORTYPE _omx_event_handler(
 }
 
 static OMX_ERRORTYPE _omx_input_required_handler(
-	UNUSED OMX_HANDLETYPE encoder,
+	UNUSED OMX_HANDLETYPE comp,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer) {
 
 	// Called by OMX when the encoder component requires
@@ -470,7 +470,7 @@ static OMX_ERRORTYPE _omx_input_required_handler(
 }
 
 static OMX_ERRORTYPE _omx_output_available_handler(
-	UNUSED OMX_HANDLETYPE encoder,
+	UNUSED OMX_HANDLETYPE comp,
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer) {
 
 	// Called by OMX when the encoder component has filled
diff --git a/src/ustreamer/encoders/omx/encoder.h b/src/ustreamer/encoders/omx/encoder.h
index 6c6b9d7..8645aa2 100644
--- a/src/ustreamer/encoders/omx/encoder.h
+++ b/src/ustreamer/encoders/omx/encoder.h
@@ -51,7 +51,7 @@
 
 
 typedef struct {
-	OMX_HANDLETYPE			encoder;
+	OMX_HANDLETYPE			comp;
 	OMX_BUFFERHEADERTYPE	*input_buffer;
 	OMX_BUFFERHEADERTYPE	*output_buffer;
 	bool					input_required;
diff --git a/src/ustreamer/h264/encoder.c b/src/ustreamer/h264/encoder.c
index adc77dc..3c0af8d 100644
--- a/src/ustreamer/h264/encoder.c
+++ b/src/ustreamer/h264/encoder.c
@@ -23,16 +23,16 @@
 #include "encoder.h"
 
 
-static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame);
-static void _h264_encoder_cleanup(h264_encoder_s *encoder);
+static int _h264_encoder_configure(h264_encoder_s *enc, const frame_s *frame);
+static void _h264_encoder_cleanup(h264_encoder_s *enc);
 
-static int _h264_encoder_compress_raw(h264_encoder_s *encoder, const frame_s *src, frame_s *dest, bool force_key);
+static int _h264_encoder_compress_raw(h264_encoder_s *enc, const frame_s *src, frame_s *dest, bool force_key);
 
 static void _mmal_callback(MMAL_WRAPPER_T *wrapper);
 static const char *_mmal_error_to_string(MMAL_STATUS_T error);
 
 
-#define RUN(_next) encoder->run->_next
+#define RUN(_next) enc->run->_next
 
 #define LOG_ERROR_MMAL(_error, _msg, ...) { \
 		LOG_ERROR(_msg ": %s", ##__VA_ARGS__, _mmal_error_to_string(_error)); \
@@ -47,12 +47,12 @@ h264_encoder_s *h264_encoder_init(void) {
 	run->tmp = frame_init("h264_tmp");
 	run->last_online = -1;
 
-	h264_encoder_s *encoder;
-	A_CALLOC(encoder, 1);
-	encoder->gop = 45; // 60
-	encoder->bps = 5000 * 1000; // Kbps * 1000
-	encoder->fps = 0; // FIXME: 30 or 0? https://github.com/6by9/yavta/blob/master/yavta.c#L210
-	encoder->run = run;
+	h264_encoder_s *enc;
+	A_CALLOC(enc, 1);
+	enc->gop = 45; // 60
+	enc->bps = 5000 * 1000; // Kbps * 1000
+	enc->fps = 0; // FIXME: 30 or 0? https://github.com/6by9/yavta/blob/master/yavta.c#L210
+	enc->run = run;
 
 	if (vcos_semaphore_create(&run->handler_sem, "h264_handler_sem", 0) != VCOS_SUCCESS) {
 		LOG_PERROR("H264: Can't create VCOS semaphore");
@@ -66,20 +66,20 @@ h264_encoder_s *h264_encoder_init(void) {
 		run->wrapper = NULL;
 		goto error;
 	}
-	run->wrapper->user_data = (void *)encoder;
+	run->wrapper->user_data = (void *)enc;
 	run->wrapper->callback = _mmal_callback;
 
-	return encoder;
+	return enc;
 
 	error:
-		h264_encoder_destroy(encoder);
+		h264_encoder_destroy(enc);
 		return NULL;
 }
 
-void h264_encoder_destroy(h264_encoder_s *encoder) {
+void h264_encoder_destroy(h264_encoder_s *enc) {
 	LOG_INFO("H264: Destroying MMAL encoder ...");
 
-	_h264_encoder_cleanup(encoder);
+	_h264_encoder_cleanup(enc);
 
 	if (RUN(wrapper)) {
 		MMAL_STATUS_T error = mmal_wrapper_destroy(RUN(wrapper));
@@ -93,11 +93,11 @@ void h264_encoder_destroy(h264_encoder_s *encoder) {
 	}
 
 	frame_destroy(RUN(tmp));
-	free(encoder->run);
-	free(encoder);
+	free(enc->run);
+	free(enc);
 }
 
-int h264_encoder_compress(h264_encoder_s *encoder, const frame_s *src, frame_s *dest) {
+int h264_encoder_compress(h264_encoder_s *enc, const frame_s *src, frame_s *dest) {
 	assert(src->used > 0);
 	assert(src->width > 0);
 	assert(src->height > 0);
@@ -121,7 +121,7 @@ int h264_encoder_compress(h264_encoder_s *encoder, const frame_s *src, frame_s *
 	src = RUN(tmp);
 
 	if (RUN(i_width) != src->width || RUN(i_height) != src->height || RUN(i_format) != src->format) {
-		if (_h264_encoder_configure(encoder, src) < 0) {
+		if (_h264_encoder_configure(enc, src) < 0) {
 			return -1;
 		}
 		RUN(last_online) = -1;
@@ -129,8 +129,8 @@ int h264_encoder_compress(h264_encoder_s *encoder, const frame_s *src, frame_s *
 
 	bool force_key = (RUN(last_online) != src->online);
 
-	if (_h264_encoder_compress_raw(encoder, src, dest, force_key) < 0) {
-		_h264_encoder_cleanup(encoder);
+	if (_h264_encoder_compress_raw(enc, src, dest, force_key) < 0) {
+		_h264_encoder_cleanup(enc);
 		return -1;
 	}
 
@@ -142,7 +142,7 @@ int h264_encoder_compress(h264_encoder_s *encoder, const frame_s *src, frame_s *
 	return 0;
 }
 
-static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame) {
+static int _h264_encoder_configure(h264_encoder_s *enc, const frame_s *frame) {
 	LOG_INFO("H264: Reconfiguring MMAL encoder ...");
 
 	MMAL_STATUS_T error;
@@ -178,7 +178,7 @@ static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame
 			} \
 		}
 
-	_h264_encoder_cleanup(encoder);
+	_h264_encoder_cleanup(enc);
 	RUN(wrapper->status) = MMAL_SUCCESS; // Это реально надо?
 
 	{
@@ -215,8 +215,8 @@ static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame
 		OFMT(type) = MMAL_ES_TYPE_VIDEO;
 		OFMT(encoding) = MMAL_ENCODING_H264;
 		OFMT(encoding_variant) = MMAL_ENCODING_VARIANT_H264_DEFAULT;
-		OFMT(bitrate) = encoder->bps;
-		OFMT(es->video.frame_rate.num) = encoder->fps;
+		OFMT(bitrate) = enc->bps;
+		OFMT(es->video.frame_rate.num) = enc->fps;
 		OFMT(es->video.frame_rate.den) = 1;
 		RUN(output_port->buffer_size) = RUN(output_port->buffer_size_recommended) * 4;
 		RUN(output_port->buffer_num) = RUN(output_port->buffer_num_recommended);
@@ -238,15 +238,15 @@ static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame
 		}
 
 		SET_PORT_PARAM(output, boolean,	ZERO_COPY,					MMAL_TRUE);
-		SET_PORT_PARAM(output, uint32,	INTRAPERIOD,				encoder->gop);
+		SET_PORT_PARAM(output, uint32,	INTRAPERIOD,				enc->gop);
 		SET_PORT_PARAM(output, uint32,	NALUNITFORMAT,				MMAL_VIDEO_NALUNITFORMAT_STARTCODES);
 		SET_PORT_PARAM(output, boolean,	MINIMISE_FRAGMENTATION,		MMAL_TRUE);
 		SET_PORT_PARAM(output, uint32,	MB_ROWS_PER_SLICE,			0);
 		SET_PORT_PARAM(output, boolean,	VIDEO_IMMUTABLE_INPUT,		MMAL_FALSE);
 		SET_PORT_PARAM(output, boolean,	VIDEO_DROPPABLE_PFRAMES,	MMAL_FALSE);
 		SET_PORT_PARAM(output, boolean,	VIDEO_ENCODE_INLINE_HEADER,	MMAL_TRUE); // SPS/PPS: https://github.com/raspberrypi/userland/issues/443
-		SET_PORT_PARAM(output, uint32,	VIDEO_BIT_RATE,				encoder->bps);
-		SET_PORT_PARAM(output, uint32,	VIDEO_ENCODE_PEAK_RATE,		encoder->bps);
+		SET_PORT_PARAM(output, uint32,	VIDEO_BIT_RATE,				enc->bps);
+		SET_PORT_PARAM(output, uint32,	VIDEO_ENCODE_PEAK_RATE,		enc->bps);
 		SET_PORT_PARAM(output, uint32,	VIDEO_ENCODE_MIN_QUANT,				16);
 		SET_PORT_PARAM(output, uint32,	VIDEO_ENCODE_MAX_QUANT,				34);
 		SET_PORT_PARAM(output, uint32,	VIDEO_ENCODE_FRAME_LIMIT_BITS,		1000000);
@@ -263,7 +263,7 @@ static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame
 	return 0;
 
 	error:
-		_h264_encoder_cleanup(encoder);
+		_h264_encoder_cleanup(enc);
 		return -1;
 
 #	undef ENABLE_PORT
@@ -272,7 +272,7 @@ static int _h264_encoder_configure(h264_encoder_s *encoder, const frame_s *frame
 #	undef PREPARE_PORT
 }
 
-static void _h264_encoder_cleanup(h264_encoder_s *encoder) {
+static void _h264_encoder_cleanup(h264_encoder_s *enc) {
 	MMAL_STATUS_T error;
 
 #	define DISABLE_PORT(_id) { \
@@ -294,7 +294,7 @@ static void _h264_encoder_cleanup(h264_encoder_s *encoder) {
 	RUN(i_format) = 0;
 }
 
-static int _h264_encoder_compress_raw(h264_encoder_s *encoder, const frame_s *src, frame_s *dest, bool force_key) {
+static int _h264_encoder_compress_raw(h264_encoder_s *enc, const frame_s *src, frame_s *dest, bool force_key) {
 	assert(src->used > 0);
 	assert(src->width == RUN(i_width));
 	assert(src->height == RUN(i_height));
diff --git a/src/ustreamer/h264/encoder.h b/src/ustreamer/h264/encoder.h
index c6e9032..158dc0f 100644
--- a/src/ustreamer/h264/encoder.h
+++ b/src/ustreamer/h264/encoder.h
@@ -65,6 +65,6 @@ typedef struct {
 
 
 h264_encoder_s *h264_encoder_init(void);
-void h264_encoder_destroy(h264_encoder_s *encoder);
+void h264_encoder_destroy(h264_encoder_s *enc);
 
-int h264_encoder_compress(h264_encoder_s *encoder, const frame_s *src, frame_s *dest);
+int h264_encoder_compress(h264_encoder_s *enc, const frame_s *src, frame_s *dest);
diff --git a/src/ustreamer/http/server.c b/src/ustreamer/http/server.c
index 877389a..8bfc96d 100644
--- a/src/ustreamer/http/server.c
+++ b/src/ustreamer/http/server.c
@@ -336,9 +336,9 @@ static void _http_callback_state(struct evhttp_request *request, void *v_server)
 
 	PREPROCESS_REQUEST;
 
-	encoder_type_e encoder_type;
-	unsigned encoder_quality;
-	encoder_get_runtime_params(STREAM(encoder), &encoder_type, &encoder_quality);
+	encoder_type_e enc_type;
+	unsigned enc_quality;
+	encoder_get_runtime_params(STREAM(enc), &enc_type, &enc_quality);
 
 	struct evbuffer *buf;
 	assert((buf = evbuffer_new()));
@@ -349,8 +349,8 @@ static void _http_callback_state(struct evhttp_request *request, void *v_server)
 		" \"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
 		" \"online\": %s, \"desired_fps\": %u, \"captured_fps\": %u},"
 		" \"stream\": {\"queued_fps\": %u, \"clients\": %u, \"clients_stat\": {",
-		encoder_type_to_string(encoder_type),
-		encoder_quality,
+		encoder_type_to_string(enc_type),
+		enc_quality,
 		(server->fake_width ? server->fake_width : EX(frame->width)),
 		(server->fake_height ? server->fake_height : EX(frame->height)),
 		bool_to_string(EX(frame->online)),
diff --git a/src/ustreamer/main.c b/src/ustreamer/main.c
index 7c9acdf..e8765c5 100644
--- a/src/ustreamer/main.c
+++ b/src/ustreamer/main.c
@@ -131,11 +131,11 @@ int main(int argc, char *argv[]) {
 
 	options_s *options = options_init(argc, argv);
 	device_s *dev = device_init();
-	encoder_s *encoder = encoder_init();
-	stream_s *stream = stream_init(dev, encoder);
+	encoder_s *enc = encoder_init();
+	stream_s *stream = stream_init(dev, enc);
 	server_s *server = server_init(stream);
 
-	if ((exit_code = options_parse(options, dev, encoder, stream, server)) == 0) {
+	if ((exit_code = options_parse(options, dev, enc, stream, server)) == 0) {
 #		ifdef WITH_GPIO
 		gpio_init();
 #		endif
@@ -168,7 +168,7 @@ int main(int argc, char *argv[]) {
 
 	server_destroy(server);
 	stream_destroy(stream);
-	encoder_destroy(encoder);
+	encoder_destroy(enc);
 	device_destroy(dev);
 	options_destroy(options);
 
diff --git a/src/ustreamer/options.c b/src/ustreamer/options.c
index 6f192ed..2c0c7a4 100644
--- a/src/ustreamer/options.c
+++ b/src/ustreamer/options.c
@@ -207,11 +207,11 @@ static const struct option _LONG_OPTS[] = {
 
 static int _parse_resolution(const char *str, unsigned *width, unsigned *height, bool limited);
 #ifdef WITH_OMX
-static int _parse_glitched_resolutions(const char *str, encoder_s *encoder);
+static int _parse_glitched_resolutions(const char *str, encoder_s *enc);
 #endif
 
 static void _features(void);
-static void _help(device_s *dev, encoder_s *encoder, stream_s *stream, server_s *server);
+static void _help(device_s *dev, encoder_s *enc, stream_s *stream, server_s *server);
 
 
 options_s *options_init(unsigned argc, char *argv[]) {
@@ -244,7 +244,7 @@ void options_destroy(options_s *options) {
 }
 
 
-int options_parse(options_s *options, device_s *dev, encoder_s *encoder, stream_s *stream, server_s *server) {
+int options_parse(options_s *options, device_s *dev, encoder_s *enc, stream_s *stream, server_s *server) {
 #	define OPT_SET(_dest, _value) { \
 			_dest = _value; \
 			break; \
@@ -353,12 +353,12 @@ int options_parse(options_s *options, device_s *dev, encoder_s *encoder, stream_
 			case _O_PERSISTENT:		OPT_SET(dev->persistent, true);
 			case _O_DV_TIMINGS:		OPT_SET(dev->dv_timings, true);
 			case _O_BUFFERS:		OPT_NUMBER("--buffers", dev->n_buffers, 1, 32, 0);
-			case _O_WORKERS:		OPT_NUMBER("--workers", encoder->n_workers, 1, 32, 0);
+			case _O_WORKERS:		OPT_NUMBER("--workers", enc->n_workers, 1, 32, 0);
 			case _O_QUALITY:		OPT_NUMBER("--quality", dev->jpeg_quality, 1, 100, 0);
-			case _O_ENCODER:		OPT_PARSE("encoder type", encoder->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN, ENCODER_TYPES_STR);
+			case _O_ENCODER:		OPT_PARSE("encoder type", enc->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN, ENCODER_TYPES_STR);
 #			ifdef WITH_OMX
 			case _O_GLITCHED_RESOLUTIONS:
-				if (_parse_glitched_resolutions(optarg, encoder) < 0) {
+				if (_parse_glitched_resolutions(optarg, enc) < 0) {
 					return -1;
 				}
 				break;
@@ -444,12 +444,12 @@ int options_parse(options_s *options, device_s *dev, encoder_s *encoder, stream_
 			case _O_FORCE_LOG_COLORS:	OPT_SET(log_colored, true);
 			case _O_NO_LOG_COLORS:		OPT_SET(log_colored, false);
 
-			case _O_HELP:		_help(dev, encoder, stream, server); return 1;
+			case _O_HELP:		_help(dev, enc, stream, server); return 1;
 			case _O_VERSION:	puts(VERSION); return 1;
 			case _O_FEATURES:	_features(); return 1;
 
 			case 0:		break;
-			default:	_help(dev, encoder, stream, server); return -1;
+			default:	_help(dev, enc, stream, server); return -1;
 		}
 	}
 
@@ -506,7 +506,7 @@ static int _parse_resolution(const char *str, unsigned *width, unsigned *height,
 }
 
 #ifdef WITH_OMX
-static int _parse_glitched_resolutions(const char *str, encoder_s *encoder) {
+static int _parse_glitched_resolutions(const char *str, encoder_s *enc) {
 	char *str_copy;
 	assert((str_copy = strdup(str)) != NULL);
 
@@ -537,14 +537,14 @@ static int _parse_glitched_resolutions(const char *str, encoder_s *encoder) {
 			default: assert(0 && "Unknown error");
 		}
 
-		encoder->glitched_resolutions[count][0] = width;
-		encoder->glitched_resolutions[count][1] = height;
+		enc->glitched_resolutions[count][0] = width;
+		enc->glitched_resolutions[count][1] = height;
 		count += 1;
 
 		ptr = strtok(NULL, ",;:\n\t ");
 	}
 
-	encoder->n_glitched_resolutions = count;
+	enc->n_glitched_resolutions = count;
 	free(str_copy);
 	return 0;
 
@@ -586,7 +586,7 @@ static void _features(void) {
 #	endif
 }
 
-static void _help(device_s *dev, encoder_s *encoder, stream_s *stream, server_s *server) {
+static void _help(device_s *dev, encoder_s *enc, stream_s *stream, server_s *server) {
 	printf("\nuStreamer - Lightweight and fast MJPG-HTTP streamer\n");
 	printf("═══════════════════════════════════════════════════\n\n");
 	printf("Version: %s; license: GPLv3\n", VERSION);
@@ -613,7 +613,7 @@ static void _help(device_s *dev, encoder_s *encoder, stream_s *stream, server_s
 	printf("                                           Each buffer may processed using an independent thread.\n");
 	printf("                                           Default: %u (the number of CPU cores (but not more than 4) + 1).\n\n", dev->n_buffers);
 	printf("    -w|--workers <N>  ──────────────────── The number of worker threads but not more than buffers.\n");
-	printf("                                           Default: %u (the number of CPU cores (but not more than 4)).\n\n", encoder->n_workers);
+	printf("                                           Default: %u (the number of CPU cores (but not more than 4)).\n\n", enc->n_workers);
 	printf("    -q|--quality <N>  ──────────────────── Set quality of JPEG encoding from 1 to 100 (best). Default: %u.\n", dev->jpeg_quality);
 	printf("                                           Note: If HW encoding is used (JPEG source format selected),\n");
 	printf("                                           this parameter attempts to configure the camera\n");
diff --git a/src/ustreamer/options.h b/src/ustreamer/options.h
index ab46a99..5d1d788 100644
--- a/src/ustreamer/options.h
+++ b/src/ustreamer/options.h
@@ -65,4 +65,4 @@ typedef struct {
 options_s *options_init(unsigned argc, char *argv[]);
 void options_destroy(options_s *options);
 
-int options_parse(options_s *options, device_s *dev, encoder_s *encoder, stream_s *stream, server_s *server);
+int options_parse(options_s *options, device_s *dev, encoder_s *enc, stream_s *stream, server_s *server);
diff --git a/src/ustreamer/stream.c b/src/ustreamer/stream.c
index 65e0b56..ceef622 100644
--- a/src/ustreamer/stream.c
+++ b/src/ustreamer/stream.c
@@ -24,7 +24,7 @@
 
 
 typedef struct {
-	encoder_s	*encoder;
+	encoder_s	*enc;
 	hw_buffer_s	*hw;
 	char		*dest_role;
 	frame_s		*dest;
@@ -46,7 +46,7 @@ static void _h264_stream_process(h264_stream_s *h264, const frame_s *frame);
 #endif
 
 
-stream_s *stream_init(device_s *dev, encoder_s *encoder) {
+stream_s *stream_init(device_s *dev, encoder_s *enc) {
 	process_s *proc;
 	A_CALLOC(proc, 1);
 	atomic_init(&proc->stop, false);
@@ -65,7 +65,7 @@ stream_s *stream_init(device_s *dev, encoder_s *encoder) {
 	stream->proc = proc;
 	stream->video = video;
 	stream->dev = dev;
-	stream->encoder = encoder;
+	stream->enc = enc;
 	return stream;
 }
 
@@ -281,7 +281,7 @@ static workers_pool_s *_stream_init_one(stream_s *stream) {
 		goto error;
 	}
 
-	encoder_prepare(stream->encoder, stream->dev);
+	encoder_prepare(stream->enc, stream->dev);
 
 #	define DEV(_next) stream->dev->_next
 #	define RUN(_next) stream->dev->run->_next
@@ -293,7 +293,7 @@ static workers_pool_s *_stream_init_one(stream_s *stream) {
 #	undef RUN
 
 	return workers_pool_init(
-		"jpeg", stream->encoder->run->n_workers, desired_interval,
+		"jpeg", stream->enc->run->n_workers, desired_interval,
 		_worker_job_init, (void *)stream,
 		_worker_job_destroy,
 		_worker_run_job);
@@ -365,7 +365,7 @@ static void *_worker_job_init(worker_s *wr, void *v_stream) {
 
 	_job_s *job;
 	A_CALLOC(job, 1);
-	job->encoder = stream->encoder;
+	job->enc = stream->enc;
 
 	const size_t dest_role_len = strlen(wr->name) + 16;
 	A_CALLOC(job->dest_role, dest_role_len);
@@ -385,7 +385,7 @@ static bool _worker_run_job(worker_s *wr) {
 	_job_s *job = (_job_s *)wr->job;
 
 	LOG_DEBUG("Worker %s compressing JPEG from buffer %u ...", wr->name, job->hw->buf_info.index);
-	bool ok = !encoder_compress(job->encoder, wr->number, &job->hw->raw, job->dest);
+	bool ok = !encoder_compress(job->enc, wr->number, &job->hw->raw, job->dest);
 	if (ok) {
 		LOG_VERBOSE("Compressed new JPEG: size=%zu, time=%0.3Lf, worker=%s, buffer=%u",
 			job->dest->used,
@@ -403,7 +403,7 @@ static h264_stream_s *_h264_stream_init(memsink_s *sink) {
 	h264_stream_s *h264;
 	A_CALLOC(h264, 1);
 
-	if ((h264->encoder = h264_encoder_init()) == NULL) {
+	if ((h264->enc = h264_encoder_init()) == NULL) {
 		goto error;
 	}
 
@@ -418,8 +418,8 @@ static h264_stream_s *_h264_stream_init(memsink_s *sink) {
 }
 
 static void _h264_stream_destroy(h264_stream_s *h264) {
-	if (h264->encoder) {
-		h264_encoder_destroy(h264->encoder);
+	if (h264->enc) {
+		h264_encoder_destroy(h264->enc);
 	}
 	if (h264->dest) {
 		frame_destroy(h264->dest);
@@ -428,7 +428,7 @@ static void _h264_stream_destroy(h264_stream_s *h264) {
 }
 
 static void _h264_stream_process(h264_stream_s *h264, const frame_s *frame) {
-	if (h264_encoder_compress(h264->encoder, frame, h264->dest) == 0) {
+	if (h264_encoder_compress(h264->enc, frame, h264->dest) == 0) {
 		memsink_server_put(h264->sink, h264->dest);
 	}
 }
diff --git a/src/ustreamer/stream.h b/src/ustreamer/stream.h
index bde4eb0..2825509 100644
--- a/src/ustreamer/stream.h
+++ b/src/ustreamer/stream.h
@@ -65,7 +65,7 @@ typedef struct {
 
 #ifdef WITH_OMX
 typedef struct {
-	h264_encoder_s	*encoder;
+	h264_encoder_s	*enc;
 	frame_s			*dest;
 	memsink_s		*sink;
 } h264_stream_s;
@@ -76,7 +76,7 @@ typedef struct {
 	unsigned	error_delay;
 
 	device_s	*dev;
-	encoder_s	*encoder;
+	encoder_s	*enc;
 	frame_s		*blank;
 #	ifdef WITH_OMX
 	memsink_s	*h264_sink;
@@ -90,7 +90,7 @@ typedef struct {
 } stream_s;
 
 
-stream_s *stream_init(device_s *dev, encoder_s *encoder);
+stream_s *stream_init(device_s *dev, encoder_s *enc);
 void stream_destroy(stream_s *stream);
 
 void stream_loop(stream_s *stream);