[libcamera-devel] [PATCH v3 28/30] py: examples: Add simple-continuous-capture.py

[Tomi Valkeinen]

Add a slightly more complex, and I think a more realistic, example,
where the script reacts to events and re-queues the buffers.

Signed-off-by: Tomi Valkeinen <tomi.valkeinen at ideasonboard.com>
---
 src/py/examples/simple-continuous-capture.py | 201 +++++++++++++++++++
 1 file changed, 201 insertions(+)
 create mode 100755 src/py/examples/simple-continuous-capture.py

diff --git a/src/py/examples/simple-continuous-capture.py b/src/py/examples/simple-continuous-capture.py
new file mode 100755
index 00000000..1c4595f6
--- /dev/null
+++ b/src/py/examples/simple-continuous-capture.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (C) 2022, Tomi Valkeinen <tomi.valkeinen at ideasonboard.com>
+
+# A simple minimal capture example showing:
+# - How to setup the camera
+# - Capture frames using events
+# - How to requeue requests
+# - Memory map the frames
+# - How to stop the camera
+
+import argparse
+import binascii
+import libcamera as libcam
+import libcamera.utils
+import selectors
+import sys
+
+
+# A simple container class for our objects
+class CaptureContext:
+    cm: libcam.CameraManager
+    cam: libcam.Camera
+    reqs: list[libcam.Request]
+    mfbs: dict[libcam.FrameBuffer, libcamera.utils.MappedFrameBuffer]
+
+
+def handle_camera_event(ctx: CaptureContext):
+    # cm.read_event() will not block here, as we know there is an event to read.
+    # We have to read the event to clear it.
+
+    ctx.cm.read_event()
+
+    reqs = ctx.cm.get_ready_requests()
+
+    # Process the captured frames
+
+    for req in reqs:
+        handle_request(ctx, req)
+
+    return True
+
+
+def handle_request(ctx: CaptureContext, req: libcam.Request):
+    buffers = req.buffers
+
+    assert len(buffers) == 1
+
+    # A ready Request could contain multiple buffers if multiple streams
+    # were being used. Here we know we only have a single stream,
+    # and we use next(iter()) to get the first and only buffer.
+
+    stream, fb = next(iter(buffers.items()))
+
+    # Use the MappedFrameBuffer to access the pixel data with CPU. We calculate
+    # the crc for each plane.
+
+    mfb = ctx.mfbs[fb]
+    crcs = [binascii.crc32(p) for p in mfb.planes]
+
+    meta = fb.metadata
+
+    print('buf {}, seq {}, bytes {}, CRCs {}'
+          .format(req.cookie,
+                  meta.sequence,
+                  '/'.join([str(p.bytes_used) for p in meta.planes]),
+                  crcs))
+
+    # We want to re-queue the buffer we just handled. Instead of creating
+    # a new Request, we re-use the old one. We need to call req.reuse()
+    # to re-initialize the Request before queuing.
+
+    req.reuse()
+    ctx.cam.queue_request(req)
+
+
+def handle_key_event():
+    sys.stdin.readline()
+    print('Exiting...')
+    return False
+
+
+def capture(ctx: CaptureContext):
+    # Queue the requests to the camera
+
+    for req in ctx.reqs:
+        ret = ctx.cam.queue_request(req)
+        assert ret == 0
+
+    # Use Selector to wait for events from the camera and from the keyboard
+
+    sel = selectors.DefaultSelector()
+    sel.register(ctx.cm.event_fd, selectors.EVENT_READ, lambda: handle_camera_event(ctx))
+    sel.register(sys.stdin, selectors.EVENT_READ, handle_key_event)
+
+    running = True
+
+    while running:
+        events = sel.select()
+        for key, mask in events:
+            # If the handler return False, we should exit
+            if not key.data():
+                running = False
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--camera', type=str, default='1',
+                        help='Camera index number (starting from 1) or part of the name')
+    parser.add_argument('-f', '--format', type=str, help='Pixel format')
+    parser.add_argument('-s', '--size', type=str, help='Size ("WxH")')
+    args = parser.parse_args()
+
+    cm = libcam.CameraManager.singleton()
+
+    try:
+        if args.camera.isnumeric():
+            cam_idx = int(args.camera)
+            cam = next((cam for i, cam in enumerate(cm.cameras) if i + 1 == cam_idx))
+        else:
+            cam = next((cam for cam in cm.cameras if args.camera in cam.id))
+    except Exception:
+        print(f'Failed to find camera "{args.camera}"')
+        return -1
+
+    # Acquire the camera for our use
+
+    ret = cam.acquire()
+    assert ret == 0
+
+    # Configure the camera
+
+    cam_config = cam.generate_configuration([libcam.StreamRole.Viewfinder])
+
+    stream_config = cam_config.at(0)
+
+    if args.format:
+        fmt = libcam.PixelFormat(args.format)
+        stream_config.pixel_format = fmt
+
+    if args.size:
+        w, h = [int(v) for v in args.size.split('x')]
+        stream_config.size = libcam.Size(w, h)
+
+    ret = cam.configure(cam_config)
+    assert ret == 0
+
+    stream = stream_config.stream
+
+    # Allocate the buffers for capture
+
+    allocator = libcam.FrameBufferAllocator(cam)
+    ret = allocator.allocate(stream)
+    assert ret > 0
+
+    num_bufs = len(allocator.buffers(stream))
+
+    print(f'Capturing {stream_config} with {num_bufs} buffers from {cam.id}')
+
+    # Create the requests and assign a buffer for each request
+
+    reqs = []
+    for i in range(num_bufs):
+        # Use the buffer index as the "cookie"
+        req = cam.create_request(i)
+
+        buffer = allocator.buffers(stream)[i]
+        ret = req.add_buffer(stream, buffer)
+        assert ret == 0
+
+        reqs.append(req)
+
+    # Start the camera
+
+    ret = cam.start()
+    assert ret == 0
+
+    ctx = CaptureContext()
+    ctx.cm = cm
+    ctx.cam = cam
+    ctx.reqs = reqs
+    ctx.mfbs = dict([(fb, libcamera.utils.MappedFrameBuffer(fb).mmap()) for fb in allocator.buffers(stream)])
+
+    capture(ctx)
+
+    # Stop the camera
+
+    ret = cam.stop()
+    assert ret == 0
+
+    # Release the camera
+
+    ret = cam.release()
+    assert ret == 0
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
-- 
2.34.1