jordan/camera-streamer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

links: rename source and sinks to capture_list and output_lists

Browse Source
This commit is contained in:
Kamil Trzcinski
2023-02-22 13:34:27 +01:00
parent bf14b915eb
commit 7c375f70a6
4 changed files with 39 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/camera-streamer/status.cc
View File

@ -84,9 +84,9 @@ static nlohmann::json links_status_json()
link_t *link = &camera->links[i];
nlohmann::json link_json;
link_json["source"] = link->source->name;
for (int j = 0; link->sinks[j]; j++) {
link_json["sinks"][j] = link->sinks[j]->name;
link_json["source"] = link->capture_list->name;
for (int j = 0; link->output_lists[j]; j++) {
link_json["sinks"][j] = link->output_lists[j]->name;
}
for (int j = 0; j < link->n_callbacks; j++) {
link_json["callbacks"][j] = link->callbacks[j].name;

8
device/camera/camera.c
View File

@ -69,13 +69,13 @@ void camera_close(camera_t **camerap)
link_t *camera_ensure_capture(camera_t *camera, buffer_list_t *capture)
{
for (int i = 0; i < camera->nlinks; i++) {
if (camera->links[i].source == capture) {
if (camera->links[i].capture_list == capture) {
return &camera->links[i];
}
}
link_t *link = &camera->links[camera->nlinks++];
link->source = capture;
link->capture_list = capture;
return link;
}
@ -84,8 +84,8 @@ void camera_capture_add_output(camera_t *camera, buffer_list_t *capture, buffer_
link_t *link = camera_ensure_capture(camera, capture);
int nsinks;
for (nsinks = 0; link->sinks[nsinks]; nsinks++);
link->sinks[nsinks] = output;
for (nsinks = 0; link->output_lists[nsinks]; nsinks++);
link->output_lists[nsinks] = output;
}
void camera_capture_add_callbacks(camera_t *camera, buffer_list_t *capture, link_callbacks_t callbacks)

60
device/links.c
View File

@ -16,19 +16,19 @@ int _build_fds(link_t *all_links, struct pollfd *fds, link_t **links, buffer_lis
uint64_t now_us __attribute__((unused)) = get_monotonic_time_us(NULL, NULL);
for (nlinks = 0; all_links[nlinks].source; nlinks++);
for (nlinks = 0; all_links[nlinks].capture_list; nlinks++);
// This traverses in reverse order as it requires to first fix outputs
// and go back into captures
for (int i = nlinks; i-- > 0; ) {
link_t *link = &all_links[i];
buffer_list_t *source = link->source;
buffer_list_t *capture_list = link->capture_list;
if (n >= max_n) {
return -EINVAL;
}
if (!source->streaming) {
if (!capture_list->streaming) {
continue;
}
@ -44,8 +44,8 @@ int _build_fds(link_t *all_links, struct pollfd *fds, link_t **links, buffer_lis
}
}
for (int j = 0; link->sinks[j]; j++) {
buffer_list_t *sink = link->sinks[j];
for (int j = 0; link->output_lists[j]; j++) {
buffer_list_t *sink = link->output_lists[j];
if (n >= max_n) {
return -EINVAL;
@ -70,20 +70,20 @@ int _build_fds(link_t *all_links, struct pollfd *fds, link_t **links, buffer_lis
}
}
source->dev->paused = paused;
capture_list->dev->paused = paused;
int count_enqueued = buffer_list_count_enqueued(source);
int count_enqueued = buffer_list_count_enqueued(capture_list);
bool can_dequeue = count_enqueued > 0;
#ifndef QUEUE_ON_CAPTURE
if (now_us - source->last_dequeued_us < source->fmt.interval_us) {
if (now_us - capture_list->last_dequeued_us < capture_list->fmt.interval_us) {
can_dequeue = false;
*max_timeout_ms = MIN(*max_timeout_ms, (source->last_dequeued_us + source->fmt.interval_us - now_us) / 1000);
*max_timeout_ms = MIN(*max_timeout_ms, (capture_list->last_dequeued_us + capture_list->fmt.interval_us - now_us) / 1000);
}
#endif
if (buffer_list_pollfd(source, &fds[n], can_dequeue) == 0) {
buf_lists[n] = source;
if (buffer_list_pollfd(capture_list, &fds[n], can_dequeue) == 0) {
buf_lists[n] = capture_list;
links[n] = link;
n++;
}
@ -118,15 +118,15 @@ bool links_sink_can_enqueue(buffer_list_t *buf_list)
return true;
}
int links_enqueue_from_source(buffer_list_t *buf_list, link_t *link)
int links_enqueue_from_capture_list(buffer_list_t *buf_list, link_t *link)
{
if (!link) {
LOG_ERROR(buf_list, "Missing link for source");
LOG_ERROR(buf_list, "Missing link for capture_list");
}
buffer_t *buf = buffer_list_dequeue(buf_list);
if (!buf) {
LOG_ERROR(buf_list, "No buffer dequeued from source?");
LOG_ERROR(buf_list, "No buffer dequeued from capture_list?");
}
for (int j = 0; j < link->n_callbacks; j++) {
@ -136,14 +136,14 @@ int links_enqueue_from_source(buffer_list_t *buf_list, link_t *link)
}
}
for (int j = 0; link->sinks[j]; j++) {
if (link->sinks[j]->dev->paused) {
for (int j = 0; link->output_lists[j]; j++) {
if (link->output_lists[j]->dev->paused) {
continue;
}
if (!links_sink_can_enqueue(link->sinks[j])) {
if (!links_sink_can_enqueue(link->output_lists[j])) {
continue;
}
buffer_list_enqueue(link->sinks[j], buf);
buffer_list_enqueue(link->output_lists[j], buf);
}
for (int j = 0; j < link->n_callbacks; j++) {
@ -220,7 +220,7 @@ static int links_step(link_t *all_links, int timeout_now_ms, int *timeout_next_m
buf_list->dev->paused);
if (fds[i].revents & POLLIN) {
if (links_enqueue_from_source(buf_list, link) < 0) {
if (links_enqueue_from_capture_list(buf_list, link) < 0) {
return -1;
}
}
@ -284,17 +284,17 @@ static int links_step(link_t *all_links, int timeout_now_ms, int *timeout_next_m
static int links_stream(link_t *all_links, bool do_stream)
{
for (int i = 0; all_links[i].source; i++) {
for (int i = 0; all_links[i].capture_list; i++) {
bool streaming = true;
link_t *link = &all_links[i];
if (buffer_list_set_stream(link->source, streaming) < 0) {
LOG_ERROR(link->source, "Failed to start streaming");
if (buffer_list_set_stream(link->capture_list, streaming) < 0) {
LOG_ERROR(link->capture_list, "Failed to start streaming");
}
for (int j = 0; link->sinks[j]; j++) {
if (buffer_list_set_stream(link->sinks[j], streaming) < 0) {
LOG_ERROR(link->sinks[j], "Failed to start streaming");
for (int j = 0; link->output_lists[j]; j++) {
if (buffer_list_set_stream(link->output_lists[j], streaming) < 0) {
LOG_ERROR(link->output_lists[j], "Failed to start streaming");
}
}
}
@ -340,20 +340,20 @@ void links_dump(link_t *all_links)
{
char line[4096];
for (int n = 0; all_links[n].source; n++) {
for (int n = 0; all_links[n].capture_list; n++) {
link_t *link = &all_links[n];
line[0] = 0;
links_dump_buf_list(line, link->source);
links_dump_buf_list(line, link->capture_list);
strcat(line, " => [");
for (int j = 0; link->sinks[j]; j++) {
for (int j = 0; link->output_lists[j]; j++) {
if (j > 0)
strcat(line, ", ");
links_dump_buf_list(line, link->sinks[j]);
links_dump_buf_list(line, link->output_lists[j]);
}
for (int j = 0; j < link->n_callbacks; j++) {
if (link->sinks[0] || j > 0)
if (link->output_lists[0] || j > 0)
strcat(line, ", ");
strcat(line, link->callbacks[j].name);
}

4
device/links.h
View File

@ -23,8 +23,8 @@ typedef struct link_callbacks_s {
} link_callbacks_t;
typedef struct link_s {
buffer_list_t *source; // capture_list
buffer_list_t *sinks[10];
buffer_list_t *capture_list;
buffer_list_t *output_lists[10];
link_callbacks_t callbacks[10];
int n_callbacks;
} link_t;