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

Rename buf_list->device to buf_list->dev

Browse Source
This commit is contained in:
Kamil Trzcinski 2022-04-11 09:00:32 +02:00
parent c42262d649
commit f5a6e4ceab
12 changed files with 32 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
device/buffer.c
View File

@ -5,7 +5,7 @@
buffer_t *buffer_open(const char *name, buffer_list_t *buf_list, int index) {
buffer_t *buf = calloc(1, sizeof(buffer_t));
device_t *dev = buf_list->device;
device_t *dev = buf_list->dev;
buf->name = strdup(name);
buf->index = index;
@ -31,7 +31,7 @@ void buffer_close(buffer_t *buf)
return;
}
buf->buf_list->device->hw->buffer_close(buf);
buf->buf_list->dev->hw->buffer_close(buf);
free(buf->name);
free(buf);
}

8
device/buffer_list.c
View File

@ -7,7 +7,7 @@ buffer_list_t *buffer_list_open(const char *name, struct device_s *dev, unsigned
{
buffer_list_t *buf_list = calloc(1, sizeof(buffer_list_t));
buf_list->device = dev;
buf_list->dev = dev;
buf_list->name = strdup(name);
buf_list->do_capture = do_capture;
buf_list->do_mmap = do_mmap;
@ -38,14 +38,14 @@ void buffer_list_close(buffer_list_t *buf_list)
buf_list->nbufs = 0;
}
buf_list->device->hw->buffer_list_close(buf_list);
buf_list->dev->hw->buffer_list_close(buf_list);
free(buf_list->name);
free(buf_list);
}
int buffer_list_set_buffers(buffer_list_t *buf_list, int nbufs)
{
int got_bufs = buf_list->device->hw->buffer_list_set_buffers(buf_list, nbufs);
int got_bufs = buf_list->dev->hw->buffer_list_set_buffers(buf_list, nbufs);
if (got_bufs <= 0) {
goto error;
}
@ -81,7 +81,7 @@ int buffer_list_set_stream(buffer_list_t *buf_list, bool do_on)
return 0;
}
if (buf_list->device->hw->buffer_list_set_stream(buf_list, do_on) < 0) {
if (buf_list->dev->hw->buffer_list_set_stream(buf_list, do_on) < 0) {
goto error;
}
buf_list->streaming = do_on;

2
device/buffer_list.h
View File

@ -9,7 +9,7 @@ struct pollfd;
typedef struct buffer_list_s {
char *name;
device_t *device;
device_t *dev;
buffer_t **bufs;
int nbufs;

6
device/buffer_queue.c
View File

@ -38,7 +38,7 @@ bool buffer_consumed(buffer_t *buf, const char *who)
buf->mmap_reflinks--;
if (!buf->enqueued && buf->mmap_reflinks == 0) {
if (buf->buf_list->device->hw->buffer_enqueue(buf, who) < 0) {
if (buf->buf_list->dev->hw->buffer_enqueue(buf, who) < 0) {
goto error;
}
@ -138,7 +138,7 @@ buffer_t *buffer_list_dequeue(buffer_list_t *buf_list)
{
buffer_t *buf = NULL;
if (buf_list->device->hw->buffer_list_dequeue(buf_list, &buf) < 0) {
if (buf_list->dev->hw->buffer_list_dequeue(buf_list, &buf) < 0) {
goto error;
}
@ -173,5 +173,5 @@ error:
int buffer_list_pollfd(buffer_list_t *buf_list, struct pollfd *pollfd, bool can_dequeue)
{
return buf_list->device->hw->buffer_list_pollfd(buf_list, pollfd, can_dequeue);
return buf_list->dev->hw->buffer_list_pollfd(buf_list, pollfd, can_dequeue);
}

2
device/device.c
View File

@ -98,7 +98,7 @@ int device_open_buffer_list_output(device_t *dev, buffer_list_t *capture_list)
capture_list->fmt_width, capture_list->fmt_height,
capture_list->fmt_format, capture_list->fmt_bytesperline,
capture_list->nbufs,
capture_list->device->allow_dma ? !capture_list->do_mmap : true);
capture_list->dev->allow_dma ? !capture_list->do_mmap : true);
}
int device_open_buffer_list_capture(device_t *dev, buffer_list_t *output_list, float div, unsigned format, bool do_mmap)

4
device/device.h
View File

@ -49,12 +49,12 @@ typedef struct device_s {
} device_t;
device_t *device_open(const char *name, const char *path, device_hw_t *hw);
void device_close(device_t *device);
void device_close(device_t *dev);
int device_open_buffer_list(device_t *dev, bool do_capture, unsigned width, unsigned height, unsigned format, unsigned bytesperline, int nbufs, bool do_mmap);
int device_open_buffer_list_output(device_t *dev, buffer_list_t *capture_list);
int device_open_buffer_list_capture(device_t *dev, buffer_list_t *output_list, float div, unsigned format, bool do_mmap);
int device_consume_event(device_t *device);
int device_consume_event(device_t *dev);
int device_set_stream(device_t *dev, bool do_on);
int device_set_decoder_start(device_t *dev, bool do_on);

14
device/links.c
View File

@ -53,15 +53,15 @@ int _build_fds(link_t *all_links, struct pollfd *fds, link_t **links, buffer_lis
// Can this chain pauses
int count_enqueued = buffer_list_count_enqueued(sink);
if (!sink->device->paused && count_enqueued < sink->nbufs) {
if (!sink->dev->paused && count_enqueued < sink->nbufs) {
paused = false;
}
}
source->device->paused = paused;
source->dev->paused = paused;
if (source->device->output_device) {
source->device->output_device->paused = paused;
if (source->dev->output_device) {
source->dev->output_device->paused = paused;
}
int count_enqueued = buffer_list_count_enqueued(source);
@ -101,7 +101,7 @@ 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]->device->paused) {
if (link->sinks[j]->dev->paused) {
continue;
}
buffer_list_enqueue(link->sinks[j], buf);
@ -173,7 +173,7 @@ int links_step(link_t *all_links, int timeout_now_ms, int *timeout_next_ms)
buf_list->streaming,
buffer_list_count_enqueued(buf_list),
buf_list->nbufs,
buf_list->device->paused);
buf_list->dev->paused);
if (fds[i].revents & POLLIN) {
if (links_enqueue_from_source(buf_list, link) < 0) {
@ -198,7 +198,7 @@ int links_step(link_t *all_links, int timeout_now_ms, int *timeout_next_ms)
return -1;
}
if (!buf_list->device->paused && buf_list->do_capture && buf_list->do_mmap) {
if (!buf_list->dev->paused && buf_list->do_capture && buf_list->do_mmap) {
buffer_t *buf;
#ifdef QUEUE_ON_CAPTURE

8
device/v4l2/buffer.c
View File

@ -10,7 +10,7 @@ int v4l2_buffer_open(buffer_t *buf)
struct v4l2_plane v4l2_plane = {0};
buffer_list_t *buf_list = buf->buf_list;
device_t *dev = buf_list->device;
device_t *dev = buf_list->dev;
buf->v4l2 = calloc(1, sizeof(buffer_v4l2_t));
@ -131,7 +131,7 @@ int v4l2_buffer_enqueue(buffer_t *buf, const char *who)
v4l2_buf.timestamp.tv_usec = buf->captured_time_us % (1000LL * 1000LL);
}
E_XIOCTL(buf, buf->buf_list->device->v4l2->dev_fd, VIDIOC_QBUF, &v4l2_buf, "Can't queue buffer.");
E_XIOCTL(buf, buf->buf_list->dev->v4l2->dev_fd, VIDIOC_QBUF, &v4l2_buf, "Can't queue buffer.");
return 0;
@ -152,7 +152,7 @@ int v4l2_buffer_list_dequeue(buffer_list_t *buf_list, buffer_t **bufp)
v4l2_buf.m.planes = &v4l2_plane;
}
E_XIOCTL(buf_list, buf_list->device->v4l2->dev_fd, VIDIOC_DQBUF, &v4l2_buf, "Can't grab capture buffer (flags=%08x)", v4l2_buf.flags);
E_XIOCTL(buf_list, buf_list->dev->v4l2->dev_fd, VIDIOC_DQBUF, &v4l2_buf, "Can't grab capture buffer (flags=%08x)", v4l2_buf.flags);
buffer_t *buf = *bufp = buf_list->bufs[v4l2_buf.index];
if (buf_list->v4l2->do_mplanes) {
@ -175,7 +175,7 @@ int v4l2_buffer_list_pollfd(buffer_list_t *buf_list, struct pollfd *pollfd, bool
int count_enqueued = buffer_list_count_enqueued(buf_list);
// Can something be dequeued?
pollfd->fd = buf_list->device->v4l2->dev_fd;
pollfd->fd = buf_list->dev->v4l2->dev_fd;
pollfd->events = POLLHUP;
if (count_enqueued > 0 && can_dequeue) {
if (buf_list->do_capture)

10
device/v4l2/buffer_list.c
View File

@ -7,7 +7,7 @@
int v4l2_buffer_list_open(buffer_list_t *buf_list, unsigned width, unsigned height, unsigned format, unsigned bytesperline)
{
device_t *dev = buf_list->device;
device_t *dev = buf_list->dev;
buf_list->v4l2 = calloc(1, sizeof(buffer_list_v4l2_t));
@ -60,7 +60,7 @@ int v4l2_buffer_list_open(buffer_list_t *buf_list, unsigned width, unsigned heig
}
E_LOG_DEBUG(buf_list, "Get current format ...");
E_XIOCTL(buf_list, buf_list->device->v4l2->dev_fd, VIDIOC_G_FMT, &fmt, "Can't set format");
E_XIOCTL(buf_list, buf_list->dev->v4l2->dev_fd, VIDIOC_G_FMT, &fmt, "Can't set format");
if (buf_list->v4l2->do_mplanes) {
fmt.fmt.pix_mp.colorspace = V4L2_COLORSPACE_JPEG;
@ -88,7 +88,7 @@ int v4l2_buffer_list_open(buffer_list_t *buf_list, unsigned width, unsigned heig
}
E_LOG_DEBUG(buf_list, "Configuring format (%s)...", fourcc_to_string(format).buf);
E_XIOCTL(buf_list, buf_list->device->v4l2->dev_fd, VIDIOC_S_FMT, &fmt, "Can't set format");
E_XIOCTL(buf_list, buf_list->dev->v4l2->dev_fd, VIDIOC_S_FMT, &fmt, "Can't set format");
if (buf_list->v4l2->do_mplanes) {
buf_list->fmt_width = fmt.fmt.pix_mp.width;
@ -147,7 +147,7 @@ int v4l2_buffer_list_set_buffers(buffer_list_t *buf_list, int nbufs)
E_LOG_DEBUG(buf_list, "Requesting %u buffers", v4l2_req.count);
E_XIOCTL(buf_list, buf_list->device->v4l2->dev_fd, VIDIOC_REQBUFS, &v4l2_req, "Can't request buffers");
E_XIOCTL(buf_list, buf_list->dev->v4l2->dev_fd, VIDIOC_REQBUFS, &v4l2_req, "Can't request buffers");
if (v4l2_req.count < 1) {
E_LOG_ERROR(buf_list, "Insufficient buffer memory: %u", v4l2_req.count);
}
@ -162,7 +162,7 @@ error:
int v4l2_buffer_list_set_stream(buffer_list_t *buf_list, bool do_on)
{
enum v4l2_buf_type type = buf_list->v4l2->type;
E_XIOCTL(buf_list, buf_list->device->v4l2->dev_fd, do_on ? VIDIOC_STREAMON : VIDIOC_STREAMOFF, &type, "Cannot set streaming state");
E_XIOCTL(buf_list, buf_list->dev->v4l2->dev_fd, do_on ? VIDIOC_STREAMON : VIDIOC_STREAMOFF, &type, "Cannot set streaming state");
return 0;
error:

2
device/v4l2/debug.c
View File

@ -28,7 +28,7 @@ int v4l2_buffer_list_refresh_states(buffer_list_t *buf_list)
for (int i = 0; i < buf_list->nbufs; i++) {
v4l2_buf.index = i;
E_XIOCTL(buf_list, buf_list->device->v4l2->dev_fd, VIDIOC_QUERYBUF, &v4l2_buf, "Can't query buffer (flags=%08x)", i);
E_XIOCTL(buf_list, buf_list->dev->v4l2->dev_fd, VIDIOC_QUERYBUF, &v4l2_buf, "Can't query buffer (flags=%08x)", i);
E_LOG_INFO(buf_list, "Buffer: %d, Flags: %08x. Offset: %d", i, v4l2_buf.flags,
buf_list->v4l2->do_mplanes ? v4l2_plane.m.mem_offset : v4l2_buf.m.offset);
}

2
http/http_ffmpeg.c
View File

@ -81,7 +81,7 @@ static int http_ffmpeg_video_buf_part(buffer_lock_t *buf_lock, buffer_t *buf, in
if (!status->had_key_frame) {
if (!status->requested_key_frame) {
device_video_force_key(buf->buf_list->device);
device_video_force_key(buf->buf_list->dev);
status->requested_key_frame = true;
}
return 0;

2
http/http_h264.c
View File

@ -73,7 +73,7 @@ int http_video_buf_part(buffer_lock_t *buf_lock, buffer_t *buf, int frame, http_
if (!status->had_key_frame) {
if (!status->requested_key_frame) {
device_video_force_key(buf->buf_list->device);
device_video_force_key(buf->buf_list->dev);
status->requested_key_frame = true;
}
return 0;