1 files changed, 53 insertions, 99 deletions

diff --git a/src/apps/lc-compliance/helpers/capture.cpp b/src/apps/lc-compliance/helpers/capture.cpp
index 43db15d2..f2c6d58c 100644
--- a/src/apps/lc-compliance/helpers/capture.cpp
+++ b/src/apps/lc-compliance/helpers/capture.cpp
@@ -7,13 +7,14 @@
 
 #include "capture.h"
 
+#include <assert.h>
+
 #include <gtest/gtest.h>
 
 using namespace libcamera;
 
 Capture::Capture(std::shared_ptr<Camera> camera)
-	: loop_(nullptr), camera_(std::move(camera)),
-	  allocator_(camera_)
+	: camera_(std::move(camera)), allocator_(camera_)
 {
 }
 
@@ -40,153 +41,106 @@ void Capture::configure(StreamRole role)
 	}
 }
 
-void Capture::start()
+void Capture::run(unsigned int captureLimit, std::optional<unsigned int> queueLimit)
 {
-	Stream *stream = config_->at(0).stream();
-	int count = allocator_.allocate(stream);
-
-	ASSERT_GE(count, 0) << "Failed to allocate buffers";
-	EXPECT_EQ(count, config_->at(0).bufferCount) << "Allocated less buffers than expected";
-
-	camera_->requestCompleted.connect(this, &Capture::requestComplete);
-
-	ASSERT_EQ(camera_->start(), 0) << "Failed to start camera";
-}
+	assert(!queueLimit || captureLimit <= *queueLimit);
 
-void Capture::stop()
-{
-	if (!config_ || !allocator_.allocated())
-		return;
+	captureLimit_ = captureLimit;
+	queueLimit_ = queueLimit;
 
-	camera_->stop();
+	captureCount_ = queueCount_ = 0;
 
-	camera_->requestCompleted.disconnect(this);
+	EventLoop loop;
+	loop_ = &loop;
 
-	Stream *stream = config_->at(0).stream();
-	requests_.clear();
-	allocator_.free(stream);
-}
-
-/* CaptureBalanced */
-
-CaptureBalanced::CaptureBalanced(std::shared_ptr<Camera> camera)
-	: Capture(std::move(camera))
-{
-}
-
-void CaptureBalanced::capture(unsigned int numRequests)
-{
 	start();
 
-	Stream *stream = config_->at(0).stream();
-	const std::vector<std::unique_ptr<FrameBuffer>> &buffers = allocator_.buffers(stream);
+	for (const auto &request : requests_)
+		queueRequest(request.get());
 
-	/* No point in testing less requests then the camera depth. */
-	if (buffers.size() > numRequests) {
-		GTEST_SKIP() << "Camera needs " << buffers.size()
-			     << " requests, can't test only " << numRequests;
-	}
+	EXPECT_EQ(loop_->exec(), 0);
 
-	queueCount_ = 0;
-	captureCount_ = 0;
-	captureLimit_ = numRequests;
-
-	/* Queue the recommended number of requests. */
-	for (const std::unique_ptr<FrameBuffer> &buffer : buffers) {
-		std::unique_ptr<Request> request = camera_->createRequest();
-		ASSERT_TRUE(request) << "Can't create request";
-
-		ASSERT_EQ(request->addBuffer(stream, buffer.get()), 0) << "Can't set buffer for request";
-
-		ASSERT_EQ(queueRequest(request.get()), 0) << "Failed to queue request";
-
-		requests_.push_back(std::move(request));
-	}
-
-	/* Run capture session. */
-	loop_ = new EventLoop();
-	loop_->exec();
 	stop();
-	delete loop_;
 
-	ASSERT_EQ(captureCount_, captureLimit_);
+	EXPECT_LE(captureLimit_, captureCount_);
+	EXPECT_LE(captureCount_, queueCount_);
+	EXPECT_TRUE(!queueLimit_ || queueCount_ <= *queueLimit_);
 }
 
-int CaptureBalanced::queueRequest(Request *request)
+int Capture::queueRequest(libcamera::Request *request)
 {
-	queueCount_++;
-	if (queueCount_ > captureLimit_)
+	if (queueLimit_ && queueCount_ >= *queueLimit_)
 		return 0;
 
-	return camera_->queueRequest(request);
+	int ret = camera_->queueRequest(request);
+	if (ret < 0)
+		return ret;
+
+	queueCount_ += 1;
+	return 0;
 }
 
-void CaptureBalanced::requestComplete(Request *request)
+void Capture::requestComplete(Request *request)
 {
-	EXPECT_EQ(request->status(), Request::Status::RequestComplete)
-		<< "Request didn't complete successfully";
-
 	captureCount_++;
 	if (captureCount_ >= captureLimit_) {
 		loop_->exit(0);
 		return;
 	}
 
+	EXPECT_EQ(request->status(), Request::Status::RequestComplete)
+		<< "Request didn't complete successfully";
+
 	request->reuse(Request::ReuseBuffers);
 	if (queueRequest(request))
 		loop_->exit(-EINVAL);
 }
 
-/* CaptureUnbalanced */
-
-CaptureUnbalanced::CaptureUnbalanced(std::shared_ptr<Camera> camera)
-	: Capture(std::move(camera))
-{
-}
-
-void CaptureUnbalanced::capture(unsigned int numRequests)
+void Capture::start()
 {
-	start();
+	assert(config_);
+	assert(!config_->empty());
+	assert(!allocator_.allocated());
+	assert(requests_.empty());
 
 	Stream *stream = config_->at(0).stream();
+	int count = allocator_.allocate(stream);
+
+	ASSERT_GE(count, 0) << "Failed to allocate buffers";
+	EXPECT_EQ(count, config_->at(0).bufferCount) << "Allocated less buffers than expected";
+
 	const std::vector<std::unique_ptr<FrameBuffer>> &buffers = allocator_.buffers(stream);
 
-	captureCount_ = 0;
-	captureLimit_ = numRequests;
+	/* No point in testing less requests then the camera depth. */
+	if (queueLimit_ && *queueLimit_ < buffers.size()) {
+		GTEST_SKIP() << "Camera needs " << buffers.size()
+			     << " requests, can't test only " << *queueLimit_;
+	}
 
-	/* Queue the recommended number of requests. */
 	for (const std::unique_ptr<FrameBuffer> &buffer : buffers) {
 		std::unique_ptr<Request> request = camera_->createRequest();
 		ASSERT_TRUE(request) << "Can't create request";
 
 		ASSERT_EQ(request->addBuffer(stream, buffer.get()), 0) << "Can't set buffer for request";
 
-		ASSERT_EQ(camera_->queueRequest(request.get()), 0) << "Failed to queue request";
-
 		requests_.push_back(std::move(request));
 	}
 
-	/* Run capture session. */
-	loop_ = new EventLoop();
-	int status = loop_->exec();
-	stop();
-	delete loop_;
+	camera_->requestCompleted.connect(this, &Capture::requestComplete);
 
-	ASSERT_EQ(status, 0);
+	ASSERT_EQ(camera_->start(), 0) << "Failed to start camera";
 }
 
-void CaptureUnbalanced::requestComplete(Request *request)
+void Capture::stop()
 {
-	captureCount_++;
-	if (captureCount_ >= captureLimit_) {
-		loop_->exit(0);
+	if (!config_ || !allocator_.allocated())
 		return;
-	}
 
-	EXPECT_EQ(request->status(), Request::Status::RequestComplete)
-		<< "Request didn't complete successfully";
+	camera_->stop();
 
-	request->reuse(Request::ReuseBuffers);
-	if (camera_->queueRequest(request))
-		loop_->exit(-EINVAL);
+	camera_->requestCompleted.disconnect(this);
+
+	Stream *stream = config_->at(0).stream();
+	requests_.clear();
+	allocator_.free(stream);
 }