366 lines
8.9 KiB
Python
Executable File
366 lines
8.9 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
# Copyright (C) 2022, Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>
|
|
|
|
from collections import defaultdict
|
|
import gc
|
|
import libcamera as libcam
|
|
import selectors
|
|
import typing
|
|
import unittest
|
|
import weakref
|
|
|
|
|
|
class BaseTestCase(unittest.TestCase):
|
|
def assertZero(self, a, msg=None):
|
|
self.assertEqual(a, 0, msg)
|
|
|
|
def assertIsAlive(self, wr, msg='object not alive'):
|
|
self.assertIsNotNone(wr(), msg)
|
|
|
|
def assertIsDead(self, wr, msg='object not dead'):
|
|
self.assertIsNone(wr(), msg)
|
|
|
|
def assertIsAllAlive(self, wr_list, msg='object not alive'):
|
|
self.assertTrue(all([wr() for wr in wr_list]), msg)
|
|
|
|
def assertIsAllDead(self, wr_list, msg='object not dead'):
|
|
self.assertTrue(all([not wr() for wr in wr_list]), msg)
|
|
|
|
|
|
class SimpleTestMethods(BaseTestCase):
|
|
def test_get_ref(self):
|
|
cm = libcam.CameraManager.singleton()
|
|
wr_cm = weakref.ref(cm)
|
|
|
|
cam = cm.get('platform/vimc.0 Sensor B')
|
|
self.assertIsNotNone(cam)
|
|
wr_cam = weakref.ref(cam)
|
|
|
|
del cm
|
|
gc.collect()
|
|
self.assertIsAlive(wr_cm)
|
|
|
|
del cam
|
|
gc.collect()
|
|
self.assertIsDead(wr_cm)
|
|
self.assertIsDead(wr_cam)
|
|
|
|
def test_acquire_release(self):
|
|
cm = libcam.CameraManager.singleton()
|
|
cam = cm.get('platform/vimc.0 Sensor B')
|
|
self.assertIsNotNone(cam)
|
|
|
|
cam.acquire()
|
|
|
|
cam.release()
|
|
|
|
def test_double_acquire(self):
|
|
cm = libcam.CameraManager.singleton()
|
|
cam = cm.get('platform/vimc.0 Sensor B')
|
|
self.assertIsNotNone(cam)
|
|
|
|
cam.acquire()
|
|
|
|
libcam.log_set_level('Camera', 'FATAL')
|
|
with self.assertRaises(RuntimeError):
|
|
cam.acquire()
|
|
libcam.log_set_level('Camera', 'ERROR')
|
|
|
|
cam.release()
|
|
|
|
# I expected exception here, but looks like double release works fine
|
|
cam.release()
|
|
|
|
def test_version(self):
|
|
cm = libcam.CameraManager.singleton()
|
|
self.assertIsInstance(cm.version, str)
|
|
|
|
|
|
class CameraTesterBase(BaseTestCase):
|
|
cm: typing.Any
|
|
cam: typing.Any
|
|
|
|
def setUp(self):
|
|
self.cm = libcam.CameraManager.singleton()
|
|
self.cam = next((cam for cam in self.cm.cameras if 'platform/vimc' in cam.id), None)
|
|
if self.cam is None:
|
|
self.cm = None
|
|
self.skipTest('No vimc found')
|
|
|
|
self.cam.acquire()
|
|
|
|
self.wr_cam = weakref.ref(self.cam)
|
|
self.wr_cm = weakref.ref(self.cm)
|
|
|
|
def tearDown(self):
|
|
# If a test fails, the camera may be in running state. So always stop.
|
|
self.cam.stop()
|
|
|
|
self.cam.release()
|
|
|
|
self.cam = None
|
|
self.cm = None
|
|
|
|
self.assertIsDead(self.wr_cm)
|
|
self.assertIsDead(self.wr_cam)
|
|
|
|
|
|
class AllocatorTestMethods(CameraTesterBase):
|
|
def test_allocator(self):
|
|
cam = self.cam
|
|
|
|
camconfig = cam.generate_configuration([libcam.StreamRole.StillCapture])
|
|
self.assertTrue(camconfig.size == 1)
|
|
wr_camconfig = weakref.ref(camconfig)
|
|
|
|
streamconfig = camconfig.at(0)
|
|
wr_streamconfig = weakref.ref(streamconfig)
|
|
|
|
cam.configure(camconfig)
|
|
|
|
stream = streamconfig.stream
|
|
wr_stream = weakref.ref(stream)
|
|
|
|
# stream should keep streamconfig and camconfig alive
|
|
del streamconfig
|
|
del camconfig
|
|
gc.collect()
|
|
self.assertIsAlive(wr_camconfig)
|
|
self.assertIsAlive(wr_streamconfig)
|
|
|
|
allocator = libcam.FrameBufferAllocator(cam)
|
|
num_bufs = allocator.allocate(stream)
|
|
self.assertTrue(num_bufs > 0)
|
|
wr_allocator = weakref.ref(allocator)
|
|
|
|
buffers = allocator.buffers(stream)
|
|
self.assertIsNotNone(buffers)
|
|
del buffers
|
|
|
|
buffer = allocator.buffers(stream)[0]
|
|
self.assertIsNotNone(buffer)
|
|
wr_buffer = weakref.ref(buffer)
|
|
|
|
del allocator
|
|
gc.collect()
|
|
self.assertIsAlive(wr_buffer)
|
|
self.assertIsAlive(wr_allocator)
|
|
self.assertIsAlive(wr_stream)
|
|
|
|
del buffer
|
|
gc.collect()
|
|
self.assertIsDead(wr_buffer)
|
|
self.assertIsDead(wr_allocator)
|
|
self.assertIsAlive(wr_stream)
|
|
|
|
del stream
|
|
gc.collect()
|
|
self.assertIsDead(wr_stream)
|
|
self.assertIsDead(wr_camconfig)
|
|
self.assertIsDead(wr_streamconfig)
|
|
|
|
|
|
class SimpleCaptureMethods(CameraTesterBase):
|
|
def test_blocking(self):
|
|
cm = self.cm
|
|
cam = self.cam
|
|
|
|
camconfig = cam.generate_configuration([libcam.StreamRole.StillCapture])
|
|
self.assertTrue(camconfig.size == 1)
|
|
|
|
streamconfig = camconfig.at(0)
|
|
fmts = streamconfig.formats
|
|
self.assertIsNotNone(fmts)
|
|
fmts = None
|
|
|
|
cam.configure(camconfig)
|
|
|
|
stream = streamconfig.stream
|
|
|
|
allocator = libcam.FrameBufferAllocator(cam)
|
|
num_bufs = allocator.allocate(stream)
|
|
self.assertTrue(num_bufs > 0)
|
|
|
|
num_bufs = len(allocator.buffers(stream))
|
|
|
|
reqs = []
|
|
for i in range(num_bufs):
|
|
req = cam.create_request(i)
|
|
self.assertIsNotNone(req)
|
|
|
|
buffer = allocator.buffers(stream)[i]
|
|
req.add_buffer(stream, buffer)
|
|
|
|
reqs.append(req)
|
|
|
|
buffer = None
|
|
|
|
cam.start()
|
|
|
|
for req in reqs:
|
|
cam.queue_request(req)
|
|
|
|
reqs = None
|
|
gc.collect()
|
|
|
|
sel = selectors.DefaultSelector()
|
|
sel.register(cm.event_fd, selectors.EVENT_READ)
|
|
|
|
reqs = []
|
|
|
|
while True:
|
|
events = sel.select()
|
|
if not events:
|
|
continue
|
|
|
|
ready_reqs = cm.get_ready_requests()
|
|
|
|
reqs += ready_reqs
|
|
|
|
if len(reqs) == num_bufs:
|
|
break
|
|
|
|
for i, req in enumerate(reqs):
|
|
self.assertTrue(i == req.cookie)
|
|
|
|
reqs = None
|
|
gc.collect()
|
|
|
|
cam.stop()
|
|
|
|
def test_select(self):
|
|
cm = self.cm
|
|
cam = self.cam
|
|
|
|
camconfig = cam.generate_configuration([libcam.StreamRole.StillCapture])
|
|
self.assertTrue(camconfig.size == 1)
|
|
|
|
streamconfig = camconfig.at(0)
|
|
fmts = streamconfig.formats
|
|
self.assertIsNotNone(fmts)
|
|
fmts = None
|
|
|
|
cam.configure(camconfig)
|
|
|
|
stream = streamconfig.stream
|
|
|
|
allocator = libcam.FrameBufferAllocator(cam)
|
|
num_bufs = allocator.allocate(stream)
|
|
self.assertTrue(num_bufs > 0)
|
|
|
|
num_bufs = len(allocator.buffers(stream))
|
|
|
|
reqs = []
|
|
for i in range(num_bufs):
|
|
req = cam.create_request(i)
|
|
self.assertIsNotNone(req)
|
|
|
|
buffer = allocator.buffers(stream)[i]
|
|
req.add_buffer(stream, buffer)
|
|
|
|
reqs.append(req)
|
|
|
|
buffer = None
|
|
|
|
cam.start()
|
|
|
|
for req in reqs:
|
|
cam.queue_request(req)
|
|
|
|
reqs = None
|
|
gc.collect()
|
|
|
|
sel = selectors.DefaultSelector()
|
|
sel.register(cm.event_fd, selectors.EVENT_READ)
|
|
|
|
reqs = []
|
|
|
|
running = True
|
|
while running:
|
|
events = sel.select()
|
|
for _ in events:
|
|
ready_reqs = cm.get_ready_requests()
|
|
|
|
reqs += ready_reqs
|
|
|
|
if len(reqs) == num_bufs:
|
|
running = False
|
|
|
|
self.assertTrue(len(reqs) == num_bufs)
|
|
|
|
for i, req in enumerate(reqs):
|
|
self.assertTrue(i == req.cookie)
|
|
|
|
reqs = None
|
|
gc.collect()
|
|
|
|
cam.stop()
|
|
|
|
|
|
# Recursively expand slist's objects into olist, using seen to track already
|
|
# processed objects.
|
|
def _getr(slist, olist, seen):
|
|
for e in slist:
|
|
if id(e) in seen:
|
|
continue
|
|
seen.add(id(e))
|
|
olist.append(e)
|
|
tl = gc.get_referents(e)
|
|
if tl:
|
|
_getr(tl, olist, seen)
|
|
|
|
|
|
def get_all_objects(ignored=[]):
|
|
gcl = gc.get_objects()
|
|
olist = []
|
|
seen = set()
|
|
|
|
seen.add(id(gcl))
|
|
seen.add(id(olist))
|
|
seen.add(id(seen))
|
|
seen.update(set([id(o) for o in ignored]))
|
|
|
|
_getr(gcl, olist, seen)
|
|
|
|
return olist
|
|
|
|
|
|
def create_type_count_map(olist):
|
|
map = defaultdict(int)
|
|
for o in olist:
|
|
map[type(o)] += 1
|
|
return map
|
|
|
|
|
|
def diff_type_count_maps(before, after):
|
|
return [(k, after[k] - before[k]) for k in after if after[k] != before[k]]
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# \todo This is an attempt to see the Python objects that are not collected,
|
|
# but this doesn't work very well, as things always leak a bit.
|
|
test_leaks = False
|
|
|
|
if test_leaks:
|
|
gc.unfreeze()
|
|
gc.collect()
|
|
|
|
obs_before = get_all_objects()
|
|
|
|
unittest.main(exit=False)
|
|
|
|
if test_leaks:
|
|
gc.unfreeze()
|
|
gc.collect()
|
|
|
|
obs_after = get_all_objects([obs_before]) # type: ignore
|
|
|
|
before = create_type_count_map(obs_before) # type: ignore
|
|
after = create_type_count_map(obs_after)
|
|
|
|
leaks = diff_type_count_maps(before, after)
|
|
if len(leaks) > 0:
|
|
print(leaks)
|