forked/ustreamer
1
0
Fork 0
mirror of https://github.com/pikvm/ustreamer.git synced 2026-02-27 04:06:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactoring

Browse Source
This commit is contained in:
Devaev Maxim
2021-01-02 17:58:23 +03:00
parent 7f089201d2
commit 5936830b28
4 changed files with 35 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/libs/common/frame.c
View File

@@ -23,10 +23,10 @@
#include "frame.h"
frame_s *frame_init(const char *role) {
frame_s *frame_init(const char *name) {
frame_s *frame;
A_CALLOC(frame, 1);
frame->role = role;
frame->name = name;
frame->managed = true;
frame_realloc_data(frame, 500 * 1024);
return frame;
@@ -44,7 +44,7 @@ void frame_realloc_data(frame_s *frame, size_t size) {
assert(frame->managed);
if (frame->allocated < size) {
LOG_DEBUG("Increasing frame buffer '%s': %zu -> %zu (+%zu)",
frame->role, frame->allocated, size, size - frame->allocated);
frame->name, frame->allocated, size, size - frame->allocated);
A_REALLOC(frame->data, size);
frame->allocated = size;
}
@@ -75,7 +75,7 @@ void frame_copy(const frame_s *src, frame_s *dest) {
}
void frame_copy_meta(const frame_s *src, frame_s *dest) {
// Don't copy the role
// Don't copy the name
COPY(width);
COPY(height);
COPY(format);

4
src/libs/common/frame.h
View File

@@ -34,7 +34,7 @@
typedef struct {
const char *role;
const char *name;
uint8_t *data;
size_t used;
@@ -52,7 +52,7 @@ typedef struct {
} frame_s;
frame_s *frame_init(const char *role);
frame_s *frame_init(const char *name);
void frame_destroy(frame_s *frame);
void frame_realloc_data(frame_s *frame, size_t size);

54
src/libs/memsink/memsink.c
View File

@@ -27,10 +27,10 @@ static int _sem_timedwait_monotonic(sem_t *sem, long double timeout);
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_open(const char *name, const char *prefix, bool server, mode_t mode, bool rm, unsigned timeout) {
memsink_s *memsink;
A_CALLOC(memsink, 1);
memsink->role = role;
memsink->name = name;
memsink->server = server;
memsink->rm = rm;
memsink->timeout = timeout;
@@ -38,18 +38,18 @@ memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t
memsink->mem = MAP_FAILED;
memsink->sig_sem = SEM_FAILED;
A_CALLOC(memsink->mem_name, strlen(name) + 8);
A_CALLOC(memsink->sig_name, strlen(name) + 8);
A_CALLOC(memsink->mem_name, strlen(prefix) + 8);
A_CALLOC(memsink->sig_name, strlen(prefix) + 8);
sprintf(memsink->mem_name, "%s.mem", name);
sprintf(memsink->sig_name, "%s.sig", name);
sprintf(memsink->mem_name, "%s.mem", prefix);
sprintf(memsink->sig_name, "%s.sig", prefix);
LOG_INFO("Using %s sink: %s.{mem,sig}", role, name);
LOG_INFO("Using %s sink: %s.{mem,sig}", name, prefix);
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); \
LOG_PERROR("Can't open %s sink signal semaphore", name); \
goto error; \
} \
}
@@ -60,12 +60,12 @@ memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t
{ // Shared memory
if ((memsink->fd = shm_open(memsink->mem_name, flags, mode)) == -1) {
LOG_PERROR("Can't open %s sink memory", role);
LOG_PERROR("Can't open %s sink memory", name);
goto error;
}
if (memsink->server && ftruncate(memsink->fd, sizeof(memsink_shared_s)) < 0) {
LOG_PERROR("Can't truncate %s sink memory", role);
LOG_PERROR("Can't truncate %s sink memory", name);
goto error;
}
@@ -77,7 +77,7 @@ memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t
memsink->fd,
0
)) == MAP_FAILED) {
LOG_PERROR("Can't mmap %s sink memory", role);
LOG_PERROR("Can't mmap %s sink memory", name);
goto error;
}
}
@@ -98,28 +98,28 @@ memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t
void memsink_close(memsink_s *memsink) {
if (memsink->sig_sem != SEM_FAILED) {
if (sem_close(memsink->sig_sem) < 0) {
LOG_PERROR("Can't close %s sink signal semaphore", memsink->role);
LOG_PERROR("Can't close %s sink signal semaphore", memsink->name);
}
if (memsink->rm && sem_unlink(memsink->sig_name) < 0) {
if (errno != ENOENT) {
LOG_PERROR("Can't remove %s sink signal semaphore", memsink->role);
LOG_PERROR("Can't remove %s sink signal semaphore", memsink->name);
}
}
}
if (memsink->mem != MAP_FAILED) {
if (munmap(memsink->mem, sizeof(memsink_shared_s)) < 0) {
LOG_PERROR("Can't unmap %s sink memory", memsink->role);
LOG_PERROR("Can't unmap %s sink memory", memsink->name);
}
}
if (memsink->fd >= 0) {
if (close(memsink->fd) < 0) {
LOG_PERROR("Can't close %s sink fd", memsink->role);
LOG_PERROR("Can't close %s sink fd", memsink->name);
}
if (memsink->rm && shm_unlink(memsink->mem_name) < 0) {
if (errno != ENOENT) {
LOG_PERROR("Can't remove %s sink memory", memsink->role);
LOG_PERROR("Can't remove %s sink memory", memsink->name);
}
}
}
@@ -136,15 +136,15 @@ int memsink_server_put(memsink_s *memsink, const frame_s *frame) {
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);
memsink->name, frame->used, MEMSINK_MAX_DATA);
return 0; // -2
}
if (_flock_timedwait_monotonic(memsink->fd, 1) == 0) {
LOG_PERF("%s sink: >>>>> Exposing new frame ...", memsink->role);
LOG_PERF("%s sink: >>>>> Exposing new frame ...", memsink->name);
if (sem_trywait(memsink->sig_sem) < 0 && errno != EAGAIN) {
LOG_PERROR("%s sink: Can't wait signal semaphore", memsink->role);
LOG_PERROR("%s sink: Can't wait signal semaphore", memsink->name);
return -1;
}
@@ -161,21 +161,21 @@ int memsink_server_put(memsink_s *memsink, const frame_s *frame) {
# undef COPY
if (sem_post(memsink->sig_sem) < 0) {
LOG_PERROR("%s sink: Can't post signal semaphore", memsink->role);
LOG_PERROR("%s sink: Can't post signal semaphore", memsink->name);
return -1;
}
if (flock(memsink->fd, LOCK_UN) < 0) {
LOG_PERROR("%s sink: Can't unlock memory", memsink->role);
LOG_PERROR("%s sink: Can't unlock memory", memsink->name);
return -1;
}
LOG_VERBOSE("%s sink: Exposed new frame; full exposition time = %Lf",
memsink->role, get_now_monotonic() - now);
memsink->name, get_now_monotonic() - now);
} else if (errno == EWOULDBLOCK) {
LOG_PERF("%s sink: ===== Shared memory is busy now; frame skipped", memsink->role);
LOG_PERF("%s sink: ===== Shared memory is busy now; frame skipped", memsink->name);
} else {
LOG_PERROR("%s sink: Can't lock memory", memsink->role);
LOG_PERROR("%s sink: Can't lock memory", memsink->name);
return -1;
}
return 0;
@@ -188,14 +188,14 @@ int memsink_client_get(memsink_s *memsink, frame_s *frame) { // cppcheck-suppres
if (errno == EAGAIN) {
return -2;
}
LOG_PERROR("%s src: Can't wait signal semaphore", memsink->role);
LOG_PERROR("%s src: Can't wait signal semaphore", memsink->name);
return -1;
}
if (_flock_timedwait_monotonic(memsink->fd, memsink->timeout) < 0) {
if (errno == EWOULDBLOCK) {
return -2;
}
LOG_PERROR("%s src: Can't lock memory", memsink->role);
LOG_PERROR("%s src: Can't lock memory", memsink->name);
return -1;
}
@@ -211,7 +211,7 @@ int memsink_client_get(memsink_s *memsink, frame_s *frame) { // cppcheck-suppres
# undef COPY
if (flock(memsink->fd, LOCK_UN) < 0) {
LOG_PERROR("%s src: Can't unlock memory", memsink->role);
LOG_PERROR("%s src: Can't unlock memory", memsink->name);
return -1;
}
return 0;

4
src/libs/memsink/memsink.h
View File

@@ -59,7 +59,7 @@ typedef struct {
} memsink_shared_s;
typedef struct {
const char *role;
const char *name;
bool server;
bool rm;
unsigned timeout;
@@ -73,7 +73,7 @@ typedef struct {
} memsink_s;
memsink_s *memsink_open(const char *role, const char *name, bool server, mode_t mode, bool rm, unsigned timeout);
memsink_s *memsink_open(const char *name, const char *prefix, bool server, mode_t mode, bool rm, unsigned timeout);
void memsink_close(memsink_s *memsink);
int memsink_server_put(memsink_s *memsink, const frame_s *frame);