forked/ustreamer
1
0
Fork 0
mirror of https://github.com/pikvm/ustreamer.git synced 2026-02-26 11:46:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactoring

Browse Source
This commit is contained in:
Devaev Maxim
2021-01-04 17:27:49 +03:00
parent 23292e9f42
commit 19b93fb237
14 changed files with 154 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/ustreamer/encoder.c
View File

@@ -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);

10
src/ustreamer/encoder.h
View File

@@ -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);

38
src/ustreamer/encoders/omx/component.c
View File

@@ -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;
}

10
src/ustreamer/encoders/omx/component.h
View File

@@ -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);

70
src/ustreamer/encoders/omx/encoder.c
View File

@@ -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

2
src/ustreamer/encoders/omx/encoder.h
View File

@@ -51,7 +51,7 @@
typedef struct {
OMX_HANDLETYPE encoder;
OMX_HANDLETYPE comp;
OMX_BUFFERHEADERTYPE *input_buffer;
OMX_BUFFERHEADERTYPE *output_buffer;
bool input_required;

62
src/ustreamer/h264/encoder.c
View File

@@ -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));

4
src/ustreamer/h264/encoder.h
View File

@@ -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);

10
src/ustreamer/http/server.c
View File

@@ -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)),

8
src/ustreamer/main.c
View File

@@ -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);

28
src/ustreamer/options.c
View File

@@ -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");

2
src/ustreamer/options.h
View File

@@ -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);

22
src/ustreamer/stream.c
View File

@@ -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);
}
}

6
src/ustreamer/stream.h
View File

@@ -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);