diff --git a/buffer_list.h b/buffer_list.h
index 4ff5189..304ee28 100644
--- a/buffer_list.h
+++ b/buffer_list.h
@@ -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);
diff --git a/buffer_queue.c b/buffer_queue.c
index 63535ec..6742244 100644
--- a/buffer_queue.c
+++ b/buffer_queue.c
@@ -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");
diff --git a/device.c b/device.c
index 4634551..5d7b218 100644
--- a/device.c
+++ b/device.c
@@ -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;
diff --git a/device.h b/device.h
index 4eecb4e..9d80b1c 100644
--- a/device.h
+++ b/device.h
@@ -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);
diff --git a/main.c b/main.c
index 4fb49bd..72c6e4e 100644
--- a/main.c
+++ b/main.c
@@ -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);