From patchwork Sun Feb 14 20:41:26 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Fabian_W=C3=BCthrich?= X-Patchwork-Id: 11291 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 1AE12BD160 for ; Sun, 14 Feb 2021 20:42:04 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 93C3D637AA; Sun, 14 Feb 2021 21:42:03 +0100 (CET) Authentication-Results: lancelot.ideasonboard.com; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=fabwu.ch header.i=@fabwu.ch header.b="3VFrMEtI"; dkim-atps=neutral Received: from gusto4.metanet.ch (gusto4.metanet.ch [80.74.154.158]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 40FF860106 for ; Sun, 14 Feb 2021 21:42:00 +0100 (CET) Received: from localhost (localhost [127.0.0.1]) by gusto4.metanet.ch (Postfix) with ESMTPSA id DCCFA4F00FD5; Sun, 14 Feb 2021 21:41:59 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=fabwu.ch; s=default; t=1613335320; bh=jYy4Nzk0HN3G/pklgK0ipqwQkfoJpfgsP5wotRvdYUo=; h=From:To:Subject; b=3VFrMEtIY2GJd+yZDolPblMVZOlZMMzJntniBHcVsgsq2QwCBXIocrc0ap6Sbckm9 uDxwKTkkJcPBeOC7V8d75t26mFzKiaSZADA3/fE7DbshvvMcxQg2AwGOsWVSgtcCEM V+YYcgtRGBMU1245xnS7KpaSvyR8lGwfG+SXYqAg= Authentication-Results: gusto.metanet.ch; spf=pass (sender IP is 2a02:1206:458b:9c20:8cba:f18c:ae7e:4c8b) smtp.mailfrom=me@fabwu.ch smtp.helo=localhost Received-SPF: pass (gusto.metanet.ch: connection is authenticated) From: =?utf-8?q?Fabian_W=C3=BCthrich?= To: libcamera-devel@lists.libcamera.org Date: Sun, 14 Feb 2021 21:41:26 +0100 Message-Id: <20210214204126.41030-1-me@fabwu.ch> X-Mailer: git-send-email 2.30.1 In-Reply-To: <20210122120132.3717-1-me@fabwu.ch> References: <20210122120132.3717-1-me@fabwu.ch> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4] libcamera: ipu3: Add rotation to ipu3 pipeline 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" Use the same transformation logic as in the raspberry pipeline to implement rotations in the ipu3 pipeline. Tested on a Surface Book 2 with an experimental driver for OV5693. Signed-off-by: Fabian Wüthrich --- Changes in v2: - Cache rotationTransform in CameraData - Use separate controls for sensor Changes in v3: - Default rotation to 0 if sensor doesn't expose it Changes in v4: - Init rotation to 0 - Drop unnecessary braces src/libcamera/pipeline/ipu3/ipu3.cpp | 80 +++++++++++++++++++++++++++- 1 file changed, 78 insertions(+), 2 deletions(-) diff --git a/src/libcamera/pipeline/ipu3/ipu3.cpp b/src/libcamera/pipeline/ipu3/ipu3.cpp index 61f7bf43..550984d1 100644 --- a/src/libcamera/pipeline/ipu3/ipu3.cpp +++ b/src/libcamera/pipeline/ipu3/ipu3.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -74,6 +75,9 @@ public: uint32_t exposureTime_; Rectangle cropRegion_; + bool supportsFlips_; + Transform rotationTransform_; + std::unique_ptr delayedCtrls_; IPU3Frames frameInfos_; @@ -91,6 +95,9 @@ public: const StreamConfiguration &cio2Format() const { return cio2Configuration_; } const ImgUDevice::PipeConfig imguConfig() const { return pipeConfig_; } + /* Cache the combinedTransform_ that will be applied to the sensor */ + Transform combinedTransform_; + private: /* * The IPU3CameraData instance is guaranteed to be valid as long as the @@ -163,11 +170,49 @@ CameraConfiguration::Status IPU3CameraConfiguration::validate() if (config_.empty()) return Invalid; - if (transform != Transform::Identity) { - transform = Transform::Identity; + Transform combined = transform * data_->rotationTransform_; + + /* + * We combine the platform and user transform, but must "adjust away" + * any combined result that includes a transposition, as we can't do those. + * In this case, flipping only the transpose bit is helpful to + * applications - they either get the transform they requested, or have + * to do a simple transpose themselves (they don't have to worry about + * the other possible cases). + */ + if (!!(combined & Transform::Transpose)) { + /* + * Flipping the transpose bit in "transform" flips it in the + * combined result too (as it's the last thing that happens), + * which is of course clearing it. + */ + transform ^= Transform::Transpose; + combined &= ~Transform::Transpose; + status = Adjusted; + } + + /* + * We also check if the sensor doesn't do h/vflips at all, in which + * case we clear them, and the application will have to do everything. + */ + if (!data_->supportsFlips_ && !!combined) { + /* + * If the sensor can do no transforms, then combined must be + * changed to the identity. The only user transform that gives + * rise to this is the inverse of the rotation. (Recall that + * combined = transform * rotationTransform.) + */ + transform = -data_->rotationTransform_; + combined = Transform::Identity; status = Adjusted; } + /* + * Store the final combined transform that configure() will need to + * apply to the sensor to save us working it out again. + */ + combinedTransform_ = combined; + /* Cap the number of entries to the available streams. */ if (config_.size() > IPU3_MAX_STREAMS) { config_.resize(IPU3_MAX_STREAMS); @@ -560,6 +605,19 @@ int PipelineHandlerIPU3::configure(Camera *camera, CameraConfiguration *c) return ret; } + /* + * Configure the H/V flip controls based on the combination of + * the sensor and user transform. + */ + if (data->supportsFlips_) { + ControlList sensor_ctrls(cio2->sensor()->controls()); + sensor_ctrls.set(V4L2_CID_HFLIP, + static_cast(!!(config->combinedTransform_ & Transform::HFlip))); + sensor_ctrls.set(V4L2_CID_VFLIP, + static_cast(!!(config->combinedTransform_ & Transform::VFlip))); + cio2->sensor()->setControls(&sensor_ctrls); + } + return 0; } @@ -999,6 +1057,24 @@ int PipelineHandlerIPU3::registerCameras() data->cio2_.frameStart().connect(data->delayedCtrls_.get(), &DelayedControls::applyControls); + /* Convert the sensor rotation to a transformation */ + int32_t rotation = 0; + if (data->properties_.contains(properties::Rotation)) + rotation = data->properties_.get(properties::Rotation); + else + LOG(IPU3, Warning) << "Rotation control not exposed by " << cio2->sensor()->id() + << ". Assume rotation 0."; + + bool success; + data->rotationTransform_ = transformFromRotation(rotation, &success); + if (!success) + LOG(IPU3, Warning) << "Invalid rotation of " << rotation << " degrees - ignoring"; + + ControlList ctrls = cio2->sensor()->getControls({ V4L2_CID_HFLIP }); + if (!ctrls.empty()) + /* We assume it will support vflips too... */ + data->supportsFlips_ = true; + /** * \todo Dynamically assign ImgU and output devices to each * stream and camera; as of now, limit support to two cameras