forked/ustreamer
1
0
Fork 0
mirror of https://github.com/pikvm/ustreamer.git synced 2026-03-16 12:33:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

size -> used

Browse Source
This commit is contained in:
Devaev Maxim
2019-03-17 19:44:49 +03:00
parent c05457ce2f
commit b31450ba41
7 changed files with 34 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/device.c
View File

@@ -238,7 +238,7 @@ int device_grab_buffer(struct device_t *dev) {
return -1; 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)); memcpy(&dev->run->hw_buffers[buf_info.index].buf_info, &buf_info, sizeof(struct v4l2_buffer));
return buf_info.index; return buf_info.index;
} }
@@ -249,7 +249,7 @@ int device_release_buffer(struct device_t *dev, unsigned index) {
LOG_PERROR("Unable to requeue buffer"); LOG_PERROR("Unable to requeue buffer");
return -1; return -1;
} }
dev->run->hw_buffers[index].size = 0; dev->run->hw_buffers[index].used = 0;
return 0; return 0;
} }

4
src/device.h
View File

@@ -43,14 +43,14 @@
struct hw_buffer_t { struct hw_buffer_t {
unsigned char *data; unsigned char *data;
size_t size; size_t used;
size_t allocated; size_t allocated;
struct v4l2_buffer buf_info; struct v4l2_buffer buf_info;
}; };
struct picture_t { struct picture_t {
unsigned char *data; unsigned char *data;
size_t size; size_t used;
size_t allocated; size_t allocated;
long double grab_time; long double grab_time;
long double encode_begin_time; long double encode_begin_time;

8
src/encoders/cpu/encoder.c
View File

@@ -81,8 +81,8 @@ void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned
# define PICTURE(_next) dev->run->pictures[index]._next # define PICTURE(_next) dev->run->pictures[index]._next
PICTURE(size) = 0; PICTURE(used) = 0;
_jpeg_set_dest_picture(&jpeg, PICTURE(data), &PICTURE(size)); _jpeg_set_dest_picture(&jpeg, PICTURE(data), &PICTURE(used));
jpeg.image_width = dev->run->width; jpeg.image_width = dev->run->width;
jpeg.image_height = dev->run->height; 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 // https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
jpeg_finish_compress(&jpeg); jpeg_finish_compress(&jpeg);
jpeg_destroy_compress(&jpeg); jpeg_destroy_compress(&jpeg);
assert(PICTURE(size) > 0); assert(PICTURE(used) > 0);
assert(PICTURE(size) <= dev->run->max_picture_size); assert(PICTURE(used) <= dev->run->max_picture_size);
} }
static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written) { static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written) {

4
src/encoders/hw/encoder.c
View File

@@ -69,8 +69,8 @@ void hw_encoder_compress_buffer(struct device_t *dev, unsigned index) {
# define PICTURE(_next) dev->run->pictures[index]._next # define PICTURE(_next) dev->run->pictures[index]._next
# define HW_BUFFER(_next) dev->run->hw_buffers[index]._next # define HW_BUFFER(_next) dev->run->hw_buffers[index]._next
assert(PICTURE(allocated) >= HW_BUFFER(size) + sizeof(HUFFMAN_TABLE)); assert(PICTURE(allocated) >= HW_BUFFER(used) + sizeof(HUFFMAN_TABLE));
PICTURE(size) = _memcpy_with_huffman(PICTURE(data), HW_BUFFER(data), HW_BUFFER(size)); PICTURE(used) = _memcpy_with_huffman(PICTURE(data), HW_BUFFER(data), HW_BUFFER(used));
# undef HW_BUFFER # undef HW_BUFFER
# undef PICTURE # undef PICTURE

16
src/encoders/omx/encoder.c
View File

@@ -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 # define OUT(_next) omx->output_buffer->_next
OMX_ERRORTYPE error; 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; size_t pos = 0;
if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) { 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; return -1;
} }
PICTURE(size) = 0; PICTURE(used) = 0;
omx->output_available = false; omx->output_available = false;
omx->input_required = true; 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) { if (omx->output_available) {
omx->output_available = false; omx->output_available = false;
assert(PICTURE(size) + OUT(nFilledLen) <= dev->run->max_picture_size); assert(PICTURE(used) + OUT(nFilledLen) <= dev->run->max_picture_size);
memcpy(PICTURE(data) + PICTURE(size), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen)); memcpy(PICTURE(data) + PICTURE(used), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen));
PICTURE(size) += OUT(nFilledLen); PICTURE(used) += OUT(nFilledLen);
if (OUT(nFlags) & OMX_BUFFERFLAG_ENDOFFRAME) { if (OUT(nFlags) & OMX_BUFFERFLAG_ENDOFFRAME) {
OUT(nFlags) = 0; 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) { if (omx->input_required) {
omx->input_required = false; omx->input_required = false;
if (pos == HW_BUFFER(size)) { if (pos == HW_BUFFER(used)) {
continue; continue;
} }
@@ -226,8 +226,8 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
pos += slice_size; pos += slice_size;
if (pos + slice_size > HW_BUFFER(size)) { if (pos + slice_size > HW_BUFFER(used)) {
slice_size = HW_BUFFER(size) - pos; slice_size = HW_BUFFER(used) - pos;
} }
if ((error = OMX_EmptyThisBuffer(omx->encoder, omx->input_buffer)) != OMX_ErrorNone) { if ((error = OMX_EmptyThisBuffer(omx->encoder, omx->input_buffer)) != OMX_ErrorNone) {

20
src/http.c
View File

@@ -324,7 +324,7 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
# define EXPOSED(_next) server->run->exposed->_next # define EXPOSED(_next) server->run->exposed->_next
assert((buf = evbuffer_new())); 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("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"); 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 "Content-Length: %zu" RN
"X-Timestamp: %.06Lf" RN "X-Timestamp: %.06Lf" RN
"%s", "%s",
EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)), EXPOSED(picture.used) * sizeof(*EXPOSED(picture.data)),
get_now_real(), (client->extra_headers ? "" : RN) get_now_real(), (client->extra_headers ? "" : RN)
)); ));
if (client->extra_headers) { 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, assert(!evbuffer_add(buf,
(void *)EXPOSED(picture.data), (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)); 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)) { if (atomic_load(&server->run->stream->updated)) {
LOG_DEBUG("Refreshing HTTP exposed ..."); LOG_DEBUG("Refreshing HTTP exposed ...");
A_MUTEX_LOCK(&server->run->stream->mutex); 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); picture_updated = _expose_new_picture(server);
UNLOCK_STREAM; UNLOCK_STREAM;
} else { } else {
@@ -683,19 +683,19 @@ static bool _expose_new_picture(struct http_server_t *server) {
# define STREAM(_next) server->run->stream->_next # define STREAM(_next) server->run->stream->_next
# define EXPOSED(_next) server->run->exposed->_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(captured_fps) = STREAM(captured_fps);
EXPOSED(expose_begin_time) = get_now_monotonic(); EXPOSED(expose_begin_time) = get_now_monotonic();
# define MEM_STREAM_TO_EXPOSED \ # define MEM_STREAM_TO_EXPOSED \
EXPOSED(picture.data), STREAM(picture.data), \ 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 (server->drop_same_frames) {
if ( if (
EXPOSED(online) EXPOSED(online)
&& EXPOSED(dropped) < server->drop_same_frames && EXPOSED(dropped) < server->drop_same_frames
&& EXPOSED(picture.size) == STREAM(picture.size) && EXPOSED(picture.used) == STREAM(picture.used)
&& !memcmp(MEM_STREAM_TO_EXPOSED) && !memcmp(MEM_STREAM_TO_EXPOSED)
) { ) {
EXPOSED(expose_cmp_time) = get_now_monotonic(); 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 # 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.grab_time) = STREAM(picture.grab_time);
EXPOSED(picture.encode_begin_time) = STREAM(picture.encode_begin_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_begin_time) = get_now_monotonic();
EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time); 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) { if (EXPOSED(picture.allocated) < BLANK_JPEG_LEN) {
A_REALLOC(EXPOSED(picture.data), BLANK_JPEG_LEN); A_REALLOC(EXPOSED(picture.data), BLANK_JPEG_LEN);
EXPOSED(picture.allocated) = 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))); 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.grab_time) = 0;
EXPOSED(picture.encode_begin_time) = 0; EXPOSED(picture.encode_begin_time) = 0;

12
src/stream.c
View File

@@ -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. // 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, // For example a VGA (640x480) webcam picture is normally >= 8kByte large,
// corrupted frames are smaller. // 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", 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; goto pass_frame;
} }
@@ -286,7 +286,7 @@ void stream_loop(struct stream_t *stream) {
} }
A_MUTEX_LOCK(&stream->mutex); A_MUTEX_LOCK(&stream->mutex);
stream->picture.size = 0; // On stream offline stream->picture.used = 0; // On stream offline
free(stream->picture.data); free(stream->picture.data);
stream->width = 0; stream->width = 0;
stream->height = 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); A_MUTEX_LOCK(&stream->mutex);
stream->picture.size = PICTURE(size); stream->picture.used = PICTURE(used);
stream->picture.allocated = PICTURE(allocated); 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.grab_time = PICTURE(grab_time);
stream->picture.encode_begin_time = PICTURE(encode_begin_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); A_MUTEX_UNLOCK(&worker->last_comp_time_mutex);
LOG_VERBOSE("Compressed JPEG size=%zu; time=%0.3Lf; worker=%u; buffer=%u", 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 { } else {
worker->job_failed = true; worker->job_failed = true;
atomic_store(&worker->has_job, false); atomic_store(&worker->has_job, false);