From patchwork Mon Mar 29 17:02:50 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Niklas_S=C3=B6derlund?= X-Patchwork-Id: 11773 X-Patchwork-Delegate: niklas.soderlund@ragnatech.se Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 05D9EC32F0 for ; Mon, 29 Mar 2021 17:03:28 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 969C468790; Mon, 29 Mar 2021 19:03:27 +0200 (CEST) Received: from bin-mail-out-05.binero.net (bin-mail-out-05.binero.net [195.74.38.228]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id EFBC268788 for ; Mon, 29 Mar 2021 19:03:25 +0200 (CEST) X-Halon-ID: ac86789d-90b0-11eb-a076-005056917f90 Authorized-sender: niklas.soderlund@fsdn.se Received: from bismarck.berto.se (p54ac5521.dip0.t-ipconnect.de [84.172.85.33]) by bin-vsp-out-02.atm.binero.net (Halon) with ESMTPA id ac86789d-90b0-11eb-a076-005056917f90; Mon, 29 Mar 2021 19:03:25 +0200 (CEST) From: =?utf-8?q?Niklas_S=C3=B6derlund?= To: libcamera-devel@lists.libcamera.org Date: Mon, 29 Mar 2021 19:02:50 +0200 Message-Id: <20210329170250.937120-4-niklas.soderlund@ragnatech.se> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210329170250.937120-1-niklas.soderlund@ragnatech.se> References: <20210329170250.937120-1-niklas.soderlund@ragnatech.se> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 3/3] lc-compliance: Add test stopping single stream with requests queued X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add a test which stops a camera while requests are still queued. This intends to test cleanup paths where requests are dequeued from video devices in an uncompleted state. Signed-off-by: Niklas Söderlund Acked-by: Kieran Bingham Tested-by: Kieran Bingham Reviewed-by: Laurent Pinchart --- * Changes since v4 - Update commit message. --- src/lc-compliance/simple_capture.cpp | 63 ++++++++++++++++++++++++++++ src/lc-compliance/simple_capture.h | 14 +++++++ src/lc-compliance/single_stream.cpp | 25 ++++++++++- 3 files changed, 101 insertions(+), 1 deletion(-) diff --git a/src/lc-compliance/simple_capture.cpp b/src/lc-compliance/simple_capture.cpp index 389dc11fc60225c5..0ff720bfd0052e45 100644 --- a/src/lc-compliance/simple_capture.cpp +++ b/src/lc-compliance/simple_capture.cpp @@ -149,3 +149,66 @@ void SimpleCaptureBalanced::requestComplete(Request *request) if (queueRequest(request)) loop_->exit(-EINVAL); } + +/* SimpleCaptureUnbalanced */ + +SimpleCaptureUnbalanced::SimpleCaptureUnbalanced(std::shared_ptr camera) + : SimpleCapture(camera) +{ +} + +Results::Result SimpleCaptureUnbalanced::capture(unsigned int numRequests) +{ + Results::Result ret = start(); + if (ret.first != Results::Pass) + return ret; + + Stream *stream = config_->at(0).stream(); + const std::vector> &buffers = allocator_->buffers(stream); + + captureCount_ = 0; + captureLimit_ = numRequests; + + /* Queue the recommended number of reqeuests. */ + std::vector> requests; + for (const std::unique_ptr &buffer : buffers) { + std::unique_ptr request = camera_->createRequest(); + if (!request) { + stop(); + return { Results::Fail, "Can't create request" }; + } + + if (request->addBuffer(stream, buffer.get())) { + stop(); + return { Results::Fail, "Can't set buffer for request" }; + } + + if (camera_->queueRequest(request.get()) < 0) { + stop(); + return { Results::Fail, "Failed to queue request" }; + } + + requests.push_back(std::move(request)); + } + + /* Run capture session. */ + loop_ = new EventLoop(); + int status = loop_->exec(); + stop(); + delete loop_; + + return { status ? Results::Fail : Results::Pass, "Unbalanced capture of " + std::to_string(numRequests) + " requests" }; +} + +void SimpleCaptureUnbalanced::requestComplete(Request *request) +{ + captureCount_++; + if (captureCount_ >= captureLimit_) { + loop_->exit(0); + return; + } + + request->reuse(Request::ReuseBuffers); + if (camera_->queueRequest(request)) + loop_->exit(-EINVAL); +} diff --git a/src/lc-compliance/simple_capture.h b/src/lc-compliance/simple_capture.h index 3a6afc538c623050..4693c13404cee7d2 100644 --- a/src/lc-compliance/simple_capture.h +++ b/src/lc-compliance/simple_capture.h @@ -51,4 +51,18 @@ private: unsigned int captureLimit_; }; +class SimpleCaptureUnbalanced : public SimpleCapture +{ +public: + SimpleCaptureUnbalanced(std::shared_ptr camera); + + Results::Result capture(unsigned int numRequests); + +private: + void requestComplete(libcamera::Request *request) override; + + unsigned int captureCount_; + unsigned int captureLimit_; +}; + #endif /* __LC_COMPLIANCE_SIMPLE_CAPTURE_H__ */ diff --git a/src/lc-compliance/single_stream.cpp b/src/lc-compliance/single_stream.cpp index e9ca1d58ecb959cd..8318b42f42d640aa 100644 --- a/src/lc-compliance/single_stream.cpp +++ b/src/lc-compliance/single_stream.cpp @@ -33,6 +33,18 @@ Results::Result testRequestBalance(std::shared_ptr camera, std::to_string(startCycles) + " start cycles" }; } +Results::Result testRequestUnbalance(std::shared_ptr camera, + StreamRole role, unsigned int numRequests) +{ + SimpleCaptureUnbalanced capture(camera); + + Results::Result ret = capture.configure(role); + if (ret.first != Results::Pass) + return ret; + + return capture.capture(numRequests); +} + Results testSingleStream(std::shared_ptr camera) { static const std::vector> roles = { @@ -43,7 +55,7 @@ Results testSingleStream(std::shared_ptr camera) }; static const std::vector numRequests = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 }; - Results results(numRequests.size() * roles.size() * 2); + Results results(numRequests.size() * roles.size() * 3); for (const auto &role : roles) { std::cout << "= Test role " << role.first << std::endl; @@ -68,6 +80,17 @@ Results testSingleStream(std::shared_ptr camera) std::cout << "* Test multiple start/stop cycles" << std::endl; for (unsigned int num : numRequests) results.add(testRequestBalance(camera, role.second, 3, num)); + + /* + * Test unbalanced stop + * + * Makes sure the camera supports a stop with requests queued. + * Example failure is a camera that does not handle cancelation + * of buffers coming back from the video device while stopping. + */ + std::cout << "* Test unbalanced stop" << std::endl; + for (unsigned int num : numRequests) + results.add(testRequestUnbalance(camera, role.second, num)); } return results;