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

WIP

Browse Source
This commit is contained in:
Kamil Trzcinski
2022-04-04 16:05:32 +02:00
parent 3c4457076b
commit b83a7f3728
5 changed files with 156 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
buffer_list.h
View File

@ -24,9 +24,10 @@ void buffer_list_close(buffer_list_t *buf_list);
int buffer_list_set_format(buffer_list_t *buffer_list, unsigned width, unsigned height, unsigned format);
int buffer_list_request(buffer_list_t *buf_list, int nbufs);
bool buffer_list_wait_pool(buffer_list_t *buf_list, int timeout);
bool buffer_list_wait_pool(buffer_list_t *buf_list, int timeout, int mmap);
int buffer_list_stream(buffer_list_t *buf_list, bool do_on);
buffer_t *buffer_list_mmap_dequeue(buffer_list_t *buf_list);
buffer_t *buffer_list_mmap_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf);
buffer_t *buffer_list_dequeue(buffer_list_t *buf_list, int mmap);
buffer_t *buffer_list_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf);

121
buffer_queue.c
View File

@ -40,42 +40,11 @@ error:
return false;
}
buffer_t *buffer_list_output_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf)
{
// if (dma_buf->enqueued || dma_buf->dma_fd < 0) {
// return NULL;
// }
// struct v4l2_buffer v4l2_buf = {0};
// struct v4l2_plane v4l2_plane = {0};
// v4l2_buf.type = buf_list->type;
// v4l2_buf.memory = V4L2_MEMORY_MMAP;
// if (buf_list->do_mplanes) {
// v4l2_buf.length = 1;
// v4l2_buf.m.planes = &v4l2_plane;
// }
// E_XIOCTL(buf_list, buf_list->device->fd, VIDIOC_DQBUF, &v4l2_buf, "Can't grab capture buffer");
// E_LOG_DEBUG(buf_list, "Grabbed INPUT buffer=%u", v4l2_buf.index);
return NULL;
}
buffer_t *buffer_list_mmap_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf)
buffer_t *_buffer_list_enqueue_mmap(buffer_list_t *buf_list, buffer_t *dma_buf)
{
buffer_t *buf = NULL;
if (!buf_list->do_mmap && !dma_buf->buf_list->do_mmap) {
E_LOG_PERROR(buf_list, "Cannot enqueue non-mmap to non-mmap: %s.", dma_buf->name);
}
if (!buf_list->do_mmap) {
E_LOG_PERROR(buf_list, "Not yet supported: %s.", dma_buf->name);
}
buf = buffer_list_mmap_dequeue(buf_list);
buf = buffer_list_dequeue(buf_list, true);
if (!buf) {
return NULL;
}
@ -91,14 +60,84 @@ buffer_t *buffer_list_mmap_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf)
buffer_consumed(buf);
return NULL;
error:
return NULL;
}
buffer_t *_buffer_list_enqueue_dmabuf(buffer_list_t *buf_list, buffer_t *dma_buf)
{
buffer_t *buf = NULL;
for (int i = 0; i < buf_list->nbufs; i++) {
if (!buf_list->bufs[i]->mmap_source) {
buf = buf_list->bufs[i];
break;
}
}
if (!buf) {
return NULL;
}
struct v4l2_buffer v4l2_buf = {0};
struct v4l2_plane v4l2_plane = {0};
v4l2_buf.type = buf_list->type;
v4l2_buf.memory = V4L2_MEMORY_DMABUF;
v4l2_buf.index = buf->index;
if (buf_list->do_mplanes) {
v4l2_buf.length = 1;
v4l2_buf.m.planes = &v4l2_plane;
v4l2_plane.m.fd = dma_buf->dma_fd;
v4l2_plane.bytesused = dma_buf->used;
v4l2_plane.length = dma_buf->used;
} else {
v4l2_buf.m.fd = dma_buf->dma_fd;
v4l2_buf.bytesused = dma_buf->used;
v4l2_buf.length = dma_buf->used;
}
// uint64_t now = get_now_monotonic_u64();
// struct timeval ts = {
// .tv_sec = now / 1000000,
// .tv_usec = now % 1000000,
// };
// v4l2_buf.timestamp.tv_sec = ts.tv_sec;
// v4l2_buf.timestamp.tv_usec = ts.tv_usec;
E_LOG_DEBUG(buf, "dmabuf copy: dest=%p, src=%p (%s, dma_fd=%d), size=%zu",
buf->start, dma_buf->start, dma_buf->name, dma_buf->dma_fd, dma_buf->used);
E_XIOCTL(buf_list, buf_list->device->fd, VIDIOC_QBUF, &v4l2_buf, "Can't push DMA buffer");
buf->mmap_source = dma_buf;
return buf;
error:
return NULL;
}
buffer_t *buffer_list_enqueue(buffer_list_t *buf_list, buffer_t *dma_buf)
{
buffer_t *buf = NULL;
if (!buf_list->do_mmap && !dma_buf->buf_list->do_mmap) {
E_LOG_PERROR(buf_list, "Cannot enqueue non-mmap to non-mmap: %s.", dma_buf->name);
}
if (buf_list->do_mmap) {
return _buffer_list_enqueue_mmap(buf_list, dma_buf);
} else {
return _buffer_list_enqueue_dmabuf(buf_list, dma_buf);
}
error:
return NULL;
}
buffer_t *buffer_list_mmap_dequeue(buffer_list_t *buf_list)
buffer_t *buffer_list_dequeue(buffer_list_t *buf_list, int mmap)
{
if (!buf_list->do_mmap) {
if (mmap != buf_list->do_mmap) {
return NULL;
}
@ -128,7 +167,11 @@ buffer_t *buffer_list_mmap_dequeue(buffer_list_t *buf_list)
E_LOG_DEBUG(buf_list, "Grabbed mmap buffer=%u, bytes=%d, used=%d",
buf->index, buf->length, buf->used);
buf->mmap_reflinks = 1;
if (buf_list->do_mmap) {
buf->mmap_reflinks = 1;
} else {
buf->mmap_reflinks = 0;
}
return buf;
@ -136,8 +179,8 @@ error:
return NULL;
}
bool buffer_list_wait_pool(buffer_list_t *buf_list, int timeout) {
struct pollfd fds = {buf_list->device->fd, POLLIN, 0};
bool buffer_list_wait_pool(buffer_list_t *buf_list, int timeout, int mmap) {
struct pollfd fds = {buf_list->device->fd, mmap ? POLLIN : POLLOUT, 0};
if (poll(&fds, 1, timeout) < 0 && errno != EINTR) {
E_LOG_ERROR(buf_list, "Can't poll encoder");
@ -151,7 +194,7 @@ bool buffer_list_wait_pool(buffer_list_t *buf_list, int timeout) {
E_LOG_DEBUG(buf_list, "fd POLLPRI");
}
if (fds.revents & POLLOUT) {
E_LOG_DEBUG(buf_list, "fd POLLOUT");
return true;
}
if (fds.revents & POLLERR) {
E_LOG_DEBUG(buf_list, "fd POLLERR");

4
device.c
View File

@ -48,7 +48,7 @@ void device_close(device_t *dev) {
free(dev);
}
int device_open_buffer_list(device_t *dev, bool do_capture, unsigned width, unsigned height, unsigned format, int nbufs)
int device_open_buffer_list(device_t *dev, bool do_capture, unsigned width, unsigned height, unsigned format, int nbufs, bool allow_dma)
{
unsigned type;
char name[64];
@ -70,7 +70,7 @@ int device_open_buffer_list(device_t *dev, bool do_capture, unsigned width, unsi
}
} else {
buf_list = &dev->output_list;
//do_mmap = true;
do_mmap = !allow_dma;
if (dev->v4l2_cap.capabilities & V4L2_CAP_VIDEO_OUTPUT) {
type = V4L2_BUF_TYPE_VIDEO_OUTPUT;

2
device.h
View File

@ -15,7 +15,7 @@ typedef struct device_s {
device_t *device_open(const char *name, const char *path);
void device_close(device_t *device);
int device_open_buffer_list(device_t *dev, bool do_capture, unsigned width, unsigned height, unsigned format, int nbufs);
int device_open_buffer_list(device_t *dev, bool do_capture, unsigned width, unsigned height, unsigned format, int nbufs, bool allow_dma);
int device_consume_event(device_t *device);
int device_stream(device_t *dev, bool do_on);

99
main.c
View File

@ -21,7 +21,7 @@ int open_camera(const char *path)
return -1;
}
if (device_open_buffer_list(camera, true, camera_width, camera_height, camera_format, camera_nbufs) < 0) {
if (device_open_buffer_list(camera, true, camera_width, camera_height, camera_format, camera_nbufs, true) < 0) {
return -1;
}
@ -38,9 +38,9 @@ int open_isp(buffer_list_t *src, const char *srgb_path, const char *yuuv_path, c
return -1;
}
if (device_open_buffer_list(isp_srgb, false, src->fmt_width, src->fmt_height, src->fmt_format, camera_nbufs) < 0 ||
device_open_buffer_list(isp_yuuv, true, src->fmt_width, src->fmt_height, V4L2_PIX_FMT_YUYV, camera_nbufs) < 0 ||
device_open_buffer_list(isp_yuuv_low, true, src->fmt_width / 2, src->fmt_height / 2, V4L2_PIX_FMT_YUYV, camera_nbufs) < 0) {
if (device_open_buffer_list(isp_srgb, false, src->fmt_width, src->fmt_height, src->fmt_format, camera_nbufs, true) < 0 ||
device_open_buffer_list(isp_yuuv, true, src->fmt_width, src->fmt_height, V4L2_PIX_FMT_YUYV, camera_nbufs, true) < 0 ||
device_open_buffer_list(isp_yuuv_low, true, src->fmt_width / 2, src->fmt_height / 2, V4L2_PIX_FMT_YUYV, camera_nbufs, true) < 0) {
return -1;
}
@ -54,14 +54,54 @@ int open_jpeg(buffer_list_t *src, const char *jpeg_codec)
return -1;
}
if (device_open_buffer_list(codec_jpeg, false, src->fmt_width, src->fmt_height, src->fmt_format, camera_nbufs) < 0 ||
device_open_buffer_list(codec_jpeg, true, src->fmt_width, src->fmt_height, V4L2_PIX_FMT_JPEG, camera_nbufs) < 0) {
if (device_open_buffer_list(codec_jpeg, false, src->fmt_width, src->fmt_height, src->fmt_format, camera_nbufs, false) < 0 ||
device_open_buffer_list(codec_jpeg, true, src->fmt_width, src->fmt_height, V4L2_PIX_FMT_JPEG, camera_nbufs, false) < 0) {
return -1;
}
return 0;
}
void connect_links(device_t **links) {
buffer_t *buf, *output_buf;
device_t *src = links[0];
if (src->capture_list->do_mmap) {
if (buffer_list_wait_pool(src->capture_list, 100, true)) {
if (buf = buffer_list_dequeue(src->capture_list, true)) {
for (int i = 1; links[i]; i++) {
buffer_list_enqueue(links[i]->output_list, buf);
if (buffer_list_wait_pool(links[i]->output_list, 10, false)) {
// consume dma-bufs
if (output_buf = buffer_list_dequeue(links[i]->output_list, false)) {
buffer_consumed(output_buf);
}
}
}
buffer_consumed(buf);
}
}
} else {
for (int i = 1; links[i]; i++) {
if (buffer_list_wait_pool(links[i]->output_list, 100, true)) {
if (output_buf = buffer_list_dequeue(links[i]->output_list, true)) {
buffer_list_enqueue(src->capture_list, output_buf);
buffer_consumed(output_buf);
}
}
}
// consume dma-bufs
if (buffer_list_wait_pool(src->capture_list, 100, false)) {
if (buf = buffer_list_dequeue(src->capture_list, false)) {
buffer_consumed(output_buf);
}
}
}
}
int main(int argc, char *argv[])
{
if (open_camera("/dev/video0") < 0) {
@ -92,33 +132,28 @@ int main(int argc, char *argv[])
goto error;
}
device_t *links[][10] = {
{
camera,
isp_srgb,
NULL
}, {
isp_yuuv,
codec_jpeg,
NULL
}, {
isp_yuuv_low,
NULL
}, {
codec_jpeg,
NULL
},
NULL
};
while(true) {
buffer_t *buf;
if (buffer_list_wait_pool(camera->capture_list, 100)) {
if (buf = buffer_list_mmap_dequeue(camera->capture_list)) {
buffer_list_mmap_enqueue(isp_srgb->output_list, buf);
buffer_consumed(buf);
}
}
if (buffer_list_wait_pool(isp_yuuv->capture_list, 100)) {
if (buf = buffer_list_mmap_dequeue(isp_yuuv->capture_list)) {
buffer_list_mmap_enqueue(codec_jpeg->output_list, buf);
buffer_consumed(buf);
}
}
if (buffer_list_wait_pool(isp_yuuv_low->capture_list, 100)) {
if (buf = buffer_list_mmap_dequeue(isp_yuuv_low->capture_list)) {
buffer_consumed(buf);
}
}
if (buffer_list_wait_pool(codec_jpeg->capture_list, 100)) {
if (buf = buffer_list_mmap_dequeue(codec_jpeg->capture_list)) {
buffer_consumed(buf);
}
for (int i = 0; links[i] && links[i][0]; i++) {
connect_links(links[i]);
}
usleep(100*1000);