refactoring

src/libs/common/frame.c

@@ -25,7 +25,6 @@
 
 frame_s *frame_init(const char *role) {
 	frame_s *frame;
-
 	A_CALLOC(frame, 1);
 	frame->role = role;
 	frame->managed = true;
@@ -60,9 +59,7 @@ void frame_set_data(frame_s *frame, const uint8_t *data, size_t size) {
 
 void frame_append_data(frame_s *frame, const uint8_t *data, size_t size) {
 	assert(frame->managed);
-
 	size_t new_used = frame->used + size;
-
 	frame_realloc_data(frame, new_used);
 	memcpy(frame->data + frame->used, data, size);
 	frame->used = new_used;

src/libs/common/tools.h

@@ -98,9 +98,7 @@ INLINE long double get_now_real(void) {
 }
 
 INLINE unsigned get_cores_available(void) {
-	long cores_sysconf;
-
-	cores_sysconf = sysconf(_SC_NPROCESSORS_ONLN);
+	long cores_sysconf = sysconf(_SC_NPROCESSORS_ONLN);
 	cores_sysconf = (cores_sysconf < 0 ? 0 : cores_sysconf);
 	return max_u(min_u(cores_sysconf, 4), 1);
 }

src/libs/h264/encoder.c

@@ -40,11 +40,10 @@ static const char *_mmal_error_to_string(MMAL_STATUS_T error);
 
 h264_encoder_s *h264_encoder_init(void) {
 	h264_encoder_runtime_s *run;
-	h264_encoder_s *encoder;
-
 	A_CALLOC(run, 1);
 	run->tmp = frame_init("h264_tmp");
 
+	h264_encoder_s *encoder;
 	A_CALLOC(encoder, 1);
 	encoder->gop = 60;
 	encoder->bps = 5000 * 1000; // Kbps * 1000
@@ -280,17 +279,13 @@ static void _h264_encoder_cleanup(h264_encoder_s *encoder) {
 }
 
 static int _h264_encoder_compress_raw(h264_encoder_s *encoder, const frame_s *src, frame_s *dest, bool force_key) {
-	MMAL_STATUS_T error;
-	MMAL_BUFFER_HEADER_T *out = NULL;
-	MMAL_BUFFER_HEADER_T *in = NULL;
-	bool eos = false;
-	bool sent = false;
-
 	assert(src->used > 0);
 	assert(src->width == encoder->width);
 	assert(src->height == encoder->height);
 	assert(src->format == encoder->format);
 
+	MMAL_STATUS_T error;
+
 	LOG_DEBUG("Compressing new H264 frame; force_key=%d ...", force_key);
 
 	frame_copy_meta(src, dest);
@@ -309,6 +304,11 @@ static int _h264_encoder_compress_raw(h264_encoder_s *encoder, const frame_s *sr
 		}
 	}
 
+	MMAL_BUFFER_HEADER_T *out = NULL;
+	MMAL_BUFFER_HEADER_T *in = NULL;
+	bool eos = false;
+	bool sent = false;
+
 	while (!eos) {
 		out = NULL;
 		while (mmal_wrapper_buffer_get_empty(RUN(output_port), &out, 0) == MMAL_SUCCESS) {

src/libs/h264/unjpeg.c

@@ -33,20 +33,19 @@ static void _jpeg_error_handler(j_common_ptr jpeg);
 
 
 int unjpeg(const frame_s *src, frame_s *dest) {
-	struct jpeg_decompress_struct jpeg;
-	_jpeg_error_manager_s jpeg_error;
-	JSAMPARRAY scanlines;
-	unsigned row_stride;
 	volatile int retval = 0;
 
+	struct jpeg_decompress_struct jpeg;
+	jpeg_create_decompress(&jpeg);
+
 	frame_realloc_data(dest, ((src->width * src->height) << 1) * 2);
 	frame_copy_meta(src, dest);
 	dest->format = V4L2_PIX_FMT_RGB24;
 	dest->used = 0;
 
-	jpeg_create_decompress(&jpeg);
-
 	// https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
+
+	_jpeg_error_manager_s jpeg_error;
 	jpeg.err = jpeg_std_error((struct jpeg_error_mgr *)&jpeg_error);
 	jpeg_error.mgr.error_exit = _jpeg_error_handler;
 	if (setjmp(jpeg_error.jmp) < 0) {
@@ -59,7 +58,9 @@ int unjpeg(const frame_s *src, frame_s *dest) {
 	jpeg.out_color_space = JCS_RGB;
 
 	jpeg_start_decompress(&jpeg);
-	row_stride = jpeg.output_width * jpeg.output_components;
+	const unsigned row_stride = jpeg.output_width * jpeg.output_components;
+
+	JSAMPARRAY scanlines;
 	scanlines = (*jpeg.mem->alloc_sarray)((j_common_ptr) &jpeg, JPOOL_IMAGE, row_stride, 1);
 
 	while (jpeg.output_scanline < jpeg.output_height) {

src/libs/memsink/memsink.c

@@ -29,8 +29,6 @@ static int _flock_timedwait_monotonic(int fd, long double timeout);
 
 memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t mode, bool rm, unsigned timeout) {
 	memsink_s *memsink;
-	int flags = (server ? O_RDWR | O_CREAT : O_RDWR);
-
 	A_CALLOC(memsink, 1);
 	memsink->role = role;
 	memsink->server = server;
@@ -48,6 +46,7 @@ memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t
 
 	LOG_INFO("Using %s sink: %s.{mem,sig}", role, name);
 
+	const int flags = (server ? O_RDWR | O_CREAT : O_RDWR);
 #	define OPEN_SIGNAL { \
 			if ((memsink->sig_sem = sem_open(memsink->sig_name, flags, mode, 0)) == SEM_FAILED) { \
 				LOG_PERROR("Can't open %s sink signal semaphore", role); \
@@ -130,11 +129,11 @@ void memsink_close(memsink_s *memsink) {
 	free(memsink);
 }
 
-int memsink_server_put(memsink_s *memsink, frame_s *frame) {
-	long double now = get_now_monotonic();
-
+int memsink_server_put(memsink_s *memsink, const frame_s *frame) {
 	assert(memsink->server);
 
+	const long double now = get_now_monotonic();
+
 	if (frame->used > MEMSINK_MAX_DATA) {
 		LOG_ERROR("%s sink: Can't put frame: is too big (%zu > %zu)",
 			memsink->role, frame->used, MEMSINK_MAX_DATA);

src/libs/memsink/memsink.h

@@ -76,5 +76,5 @@ typedef struct {
 memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t mode, bool rm, unsigned timeout);
 void memsink_close(memsink_s *memsink);
 
-int memsink_server_put(memsink_s *memsink, frame_s *frame);
+int memsink_server_put(memsink_s *memsink, const frame_s *frame);
 int memsink_client_get(memsink_s *memsink, frame_s *frame);