From b31450ba412f026e331a501a57d1693b245daa21 Mon Sep 17 00:00:00 2001 From: Devaev Maxim Date: Sun, 17 Mar 2019 19:44:49 +0300 Subject: [PATCH] size -> used --- src/device.c | 4 ++-- src/device.h | 4 ++-- src/encoders/cpu/encoder.c | 8 ++++---- src/encoders/hw/encoder.c | 4 ++-- src/encoders/omx/encoder.c | 16 ++++++++-------- src/http.c | 20 ++++++++++---------- src/stream.c | 12 ++++++------ 7 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/device.c b/src/device.c index 4c075b8..a1322c2 100644 --- a/src/device.c +++ b/src/device.c @@ -238,7 +238,7 @@ int device_grab_buffer(struct device_t *dev) { return -1; } - dev->run->hw_buffers[buf_info.index].size = buf_info.bytesused; + dev->run->hw_buffers[buf_info.index].used = buf_info.bytesused; memcpy(&dev->run->hw_buffers[buf_info.index].buf_info, &buf_info, sizeof(struct v4l2_buffer)); return buf_info.index; } @@ -249,7 +249,7 @@ int device_release_buffer(struct device_t *dev, unsigned index) { LOG_PERROR("Unable to requeue buffer"); return -1; } - dev->run->hw_buffers[index].size = 0; + dev->run->hw_buffers[index].used = 0; return 0; } diff --git a/src/device.h b/src/device.h index 966b8c0..e495e03 100644 --- a/src/device.h +++ b/src/device.h @@ -43,14 +43,14 @@ struct hw_buffer_t { unsigned char *data; - size_t size; + size_t used; size_t allocated; struct v4l2_buffer buf_info; }; struct picture_t { unsigned char *data; - size_t size; + size_t used; size_t allocated; long double grab_time; long double encode_begin_time; diff --git a/src/encoders/cpu/encoder.c b/src/encoders/cpu/encoder.c index 4fbe23c..d29938d 100644 --- a/src/encoders/cpu/encoder.c +++ b/src/encoders/cpu/encoder.c @@ -81,8 +81,8 @@ void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned # define PICTURE(_next) dev->run->pictures[index]._next - PICTURE(size) = 0; - _jpeg_set_dest_picture(&jpeg, PICTURE(data), &PICTURE(size)); + PICTURE(used) = 0; + _jpeg_set_dest_picture(&jpeg, PICTURE(data), &PICTURE(used)); jpeg.image_width = dev->run->width; jpeg.image_height = dev->run->height; @@ -112,8 +112,8 @@ void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned // https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg jpeg_finish_compress(&jpeg); jpeg_destroy_compress(&jpeg); - assert(PICTURE(size) > 0); - assert(PICTURE(size) <= dev->run->max_picture_size); + assert(PICTURE(used) > 0); + assert(PICTURE(used) <= dev->run->max_picture_size); } static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written) { diff --git a/src/encoders/hw/encoder.c b/src/encoders/hw/encoder.c index 77afd8a..63c7419 100644 --- a/src/encoders/hw/encoder.c +++ b/src/encoders/hw/encoder.c @@ -69,8 +69,8 @@ void hw_encoder_compress_buffer(struct device_t *dev, unsigned index) { # define PICTURE(_next) dev->run->pictures[index]._next # define HW_BUFFER(_next) dev->run->hw_buffers[index]._next - assert(PICTURE(allocated) >= HW_BUFFER(size) + sizeof(HUFFMAN_TABLE)); - PICTURE(size) = _memcpy_with_huffman(PICTURE(data), HW_BUFFER(data), HW_BUFFER(size)); + assert(PICTURE(allocated) >= HW_BUFFER(used) + sizeof(HUFFMAN_TABLE)); + PICTURE(used) = _memcpy_with_huffman(PICTURE(data), HW_BUFFER(data), HW_BUFFER(used)); # undef HW_BUFFER # undef PICTURE diff --git a/src/encoders/omx/encoder.c b/src/encoders/omx/encoder.c index c5e72e3..a29a368 100644 --- a/src/encoders/omx/encoder.c +++ b/src/encoders/omx/encoder.c @@ -178,7 +178,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, # define OUT(_next) omx->output_buffer->_next OMX_ERRORTYPE error; - size_t slice_size = (IN(nAllocLen) < HW_BUFFER(size) ? IN(nAllocLen) : HW_BUFFER(size)); + size_t slice_size = (IN(nAllocLen) < HW_BUFFER(used) ? IN(nAllocLen) : HW_BUFFER(used)); size_t pos = 0; if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) { @@ -186,7 +186,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, return -1; } - PICTURE(size) = 0; + PICTURE(used) = 0; omx->output_available = false; omx->input_required = true; @@ -198,9 +198,9 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, if (omx->output_available) { omx->output_available = false; - assert(PICTURE(size) + OUT(nFilledLen) <= dev->run->max_picture_size); - memcpy(PICTURE(data) + PICTURE(size), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen)); - PICTURE(size) += OUT(nFilledLen); + assert(PICTURE(used) + OUT(nFilledLen) <= dev->run->max_picture_size); + memcpy(PICTURE(data) + PICTURE(used), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen)); + PICTURE(used) += OUT(nFilledLen); if (OUT(nFlags) & OMX_BUFFERFLAG_ENDOFFRAME) { OUT(nFlags) = 0; @@ -216,7 +216,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, if (omx->input_required) { omx->input_required = false; - if (pos == HW_BUFFER(size)) { + if (pos == HW_BUFFER(used)) { continue; } @@ -226,8 +226,8 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, pos += slice_size; - if (pos + slice_size > HW_BUFFER(size)) { - slice_size = HW_BUFFER(size) - pos; + if (pos + slice_size > HW_BUFFER(used)) { + slice_size = HW_BUFFER(used) - pos; } if ((error = OMX_EmptyThisBuffer(omx->encoder, omx->input_buffer)) != OMX_ErrorNone) { diff --git a/src/http.c b/src/http.c index 3077c5a..9f391eb 100644 --- a/src/http.c +++ b/src/http.c @@ -324,7 +324,7 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv # define EXPOSED(_next) server->run->exposed->_next assert((buf = evbuffer_new())); - assert(!evbuffer_add(buf, (const void *)EXPOSED(picture.data), EXPOSED(picture.size))); + assert(!evbuffer_add(buf, (const void *)EXPOSED(picture.data), EXPOSED(picture.used))); ADD_HEADER("Access-Control-Allow-Origin:", "*"); ADD_HEADER("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate, pre-check=0, post-check=0, max-age=0"); @@ -505,7 +505,7 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c "Content-Length: %zu" RN "X-Timestamp: %.06Lf" RN "%s", - EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)), + EXPOSED(picture.used) * sizeof(*EXPOSED(picture.data)), get_now_real(), (client->extra_headers ? "" : RN) )); if (client->extra_headers) { @@ -541,7 +541,7 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c assert(!evbuffer_add(buf, (void *)EXPOSED(picture.data), - EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)) + EXPOSED(picture.used) * sizeof(*EXPOSED(picture.data)) )); assert(evbuffer_add_printf(buf, RN "--" BOUNDARY RN)); @@ -660,7 +660,7 @@ static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_serv if (atomic_load(&server->run->stream->updated)) { LOG_DEBUG("Refreshing HTTP exposed ..."); A_MUTEX_LOCK(&server->run->stream->mutex); - if (server->run->stream->picture.size > 0) { // If online + if (server->run->stream->picture.used > 0) { // If online picture_updated = _expose_new_picture(server); UNLOCK_STREAM; } else { @@ -683,19 +683,19 @@ static bool _expose_new_picture(struct http_server_t *server) { # define STREAM(_next) server->run->stream->_next # define EXPOSED(_next) server->run->exposed->_next - assert(STREAM(picture.size) > 0); + assert(STREAM(picture.used) > 0); EXPOSED(captured_fps) = STREAM(captured_fps); EXPOSED(expose_begin_time) = get_now_monotonic(); # define MEM_STREAM_TO_EXPOSED \ EXPOSED(picture.data), STREAM(picture.data), \ - STREAM(picture.size) * sizeof(*STREAM(picture.data)) + STREAM(picture.used) * sizeof(*STREAM(picture.data)) if (server->drop_same_frames) { if ( EXPOSED(online) && EXPOSED(dropped) < server->drop_same_frames - && EXPOSED(picture.size) == STREAM(picture.size) + && EXPOSED(picture.used) == STREAM(picture.used) && !memcmp(MEM_STREAM_TO_EXPOSED) ) { EXPOSED(expose_cmp_time) = get_now_monotonic(); @@ -720,7 +720,7 @@ static bool _expose_new_picture(struct http_server_t *server) { # undef MEM_STREAM_TO_EXPOSED - EXPOSED(picture.size) = STREAM(picture.size); + EXPOSED(picture.used) = STREAM(picture.used); EXPOSED(picture.grab_time) = STREAM(picture.grab_time); EXPOSED(picture.encode_begin_time) = STREAM(picture.encode_begin_time); @@ -748,7 +748,7 @@ static bool _expose_blank_picture(struct http_server_t *server) { EXPOSED(expose_begin_time) = get_now_monotonic(); EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time); - if (EXPOSED(online) || EXPOSED(picture.size) == 0) { + if (EXPOSED(online) || EXPOSED(picture.used) == 0) { if (EXPOSED(picture.allocated) < BLANK_JPEG_LEN) { A_REALLOC(EXPOSED(picture.data), BLANK_JPEG_LEN); EXPOSED(picture.allocated) = BLANK_JPEG_LEN; @@ -756,7 +756,7 @@ static bool _expose_blank_picture(struct http_server_t *server) { memcpy(EXPOSED(picture.data), BLANK_JPEG_DATA, BLANK_JPEG_LEN * sizeof(*EXPOSED(picture.data))); - EXPOSED(picture.size) = BLANK_JPEG_LEN; + EXPOSED(picture.used) = BLANK_JPEG_LEN; EXPOSED(picture.grab_time) = 0; EXPOSED(picture.encode_begin_time) = 0; diff --git a/src/stream.c b/src/stream.c index 6fd5585..e13afc8 100644 --- a/src/stream.c +++ b/src/stream.c @@ -200,9 +200,9 @@ void stream_loop(struct stream_t *stream) { // The good thing is such frames are quite small compared to the regular pictures. // For example a VGA (640x480) webcam picture is normally >= 8kByte large, // corrupted frames are smaller. - if (stream->dev->run->hw_buffers[buf_index].size < stream->dev->min_frame_size) { + if (stream->dev->run->hw_buffers[buf_index].used < stream->dev->min_frame_size) { LOG_DEBUG("Dropping too small frame sized %zu bytes, assuming it as broken", - stream->dev->run->hw_buffers[buf_index].size); + stream->dev->run->hw_buffers[buf_index].used); goto pass_frame; } @@ -286,7 +286,7 @@ void stream_loop(struct stream_t *stream) { } A_MUTEX_LOCK(&stream->mutex); - stream->picture.size = 0; // On stream offline + stream->picture.used = 0; // On stream offline free(stream->picture.data); stream->width = 0; stream->height = 0; @@ -312,10 +312,10 @@ static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index) A_MUTEX_LOCK(&stream->mutex); - stream->picture.size = PICTURE(size); + stream->picture.used = PICTURE(used); stream->picture.allocated = PICTURE(allocated); - memcpy(stream->picture.data, PICTURE(data), stream->picture.size * sizeof(*stream->picture.data)); + memcpy(stream->picture.data, PICTURE(data), stream->picture.used * sizeof(*stream->picture.data)); stream->picture.grab_time = PICTURE(grab_time); stream->picture.encode_begin_time = PICTURE(encode_begin_time); @@ -468,7 +468,7 @@ static void *_stream_worker_thread(void *v_worker) { A_MUTEX_UNLOCK(&worker->last_comp_time_mutex); LOG_VERBOSE("Compressed JPEG size=%zu; time=%0.3Lf; worker=%u; buffer=%u", - PICTURE(size), last_comp_time, worker->number, worker->buf_index); + PICTURE(used), last_comp_time, worker->number, worker->buf_index); } else { worker->job_failed = true; atomic_store(&worker->has_job, false);