From patchwork Thu Jan 3 01:31:10 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Laurent Pinchart X-Patchwork-Id: 143 Return-Path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 2CAC060B36 for ; Thu, 3 Jan 2019 02:30:16 +0100 (CET) Received: from avalon.bb.dnainternet.fi (dfj612ybrt5fhg77mgycy-3.rev.dnainternet.fi [IPv6:2001:14ba:21f5:5b00:2e86:4862:ef6a:2804]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id BC76B573 for ; Thu, 3 Jan 2019 02:30:15 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1546479015; bh=sYqxjfIaQ4VBgXBP5C/eJWIC3HtEuedHBuw6g1fAucM=; h=From:To:Subject:Date:In-Reply-To:References:From; b=EnmqHEmAZ4+gsu8F5nEjmAYSbgBDn4IDZwIAPMaYxp7qjMSy2zcu455LlL3UpPbum 4sZ+fKbeyqttwNCmIMpgy/V23GzAO+gAGRjIfY7njhKwfmZa5RTQn1Y8jECEN+icTb Np0C+B98CUe2pfglJn6cpxi61WL1HBEV75PWWNV4= From: Laurent Pinchart To: libcamera-devel@lists.libcamera.org Date: Thu, 3 Jan 2019 03:31:10 +0200 Message-Id: <20190103013110.6849-9-laurent.pinchart@ideasonboard.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190103013110.6849-1-laurent.pinchart@ideasonboard.com> References: <20190103013110.6849-1-laurent.pinchart@ideasonboard.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 9/9] libcamera: pipeline_handler: Improve documentation X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 03 Jan 2019 01:30:16 -0000 Miscellaneous documentation improvements for the PipelineHandler and related classes. Signed-off-by: Laurent Pinchart Reviewed-by: Niklas Söderlund --- src/libcamera/pipeline_handler.cpp | 125 ++++++++++++++++++++--------- 1 file changed, 88 insertions(+), 37 deletions(-) diff --git a/src/libcamera/pipeline_handler.cpp b/src/libcamera/pipeline_handler.cpp index a737f222b465..093821d4c471 100644 --- a/src/libcamera/pipeline_handler.cpp +++ b/src/libcamera/pipeline_handler.cpp @@ -11,48 +11,98 @@ /** * \file pipeline_handler.h - * \brief Create pipelines and cameras from one or more media devices + * \brief Create pipelines and cameras from a set of media devices * * Each pipeline supported by libcamera needs to be backed by a pipeline - * handler implementation which describes the one or many media devices - * needed for a pipeline to function properly. + * handler implementation that operate on a set of media devices. The pipeline + * handler is responsible for matching the media devices it requires with the + * devices present in the system, and once all those devices can be acquired, + * create corresponding Camera instances. * - * The pipeline handler is responsible for providing a description of the - * media devices it requires to operate. Once all media devices can be - * provided the pipeline handler can acquire them and create camera - * devices that utilize the acquired media devices. - * - * To make it a bit less bit complicated to write pipe line handlers a - * macro REGISTER_PIPELINE_HANDLER() is provided which allows a pipeline - * handler implementation to register itself with the library with ease. + * Every subclass of PipelineHandler shall be registered with libcamera using + * the REGISTER_PIPELINE_HANDLER() macro. */ namespace libcamera { /** * \class PipelineHandler - * \brief Find a set of media devices and provide cameras + * \brief Create and manage cameras based on a set of media devices * - * The responsibility of a PipelineHandler is to describe all media - * devices it would need in order to provide cameras to the system. + * The PipelineHandler matches the media devices provided by a DeviceEnumerator + * with the pipelines it supports and creates corresponding Camera devices. + */ + +/** + * \fn PipelineHandler::match(DeviceEnumerator *enumerator) + * \brief Match media devices and create camera instances + * + * This function is the main entry point of the pipeline handler. It is called + * by the device enumerator with the enumerator passed as an argument. It shall + * acquire from the enumerator all the media devices it needs for a single + * pipeline and create one or multiple Camera instances. + * + * If all media devices needed by the pipeline handler are found, they must all + * be acquired by a call to MediaDevice::acquire(). This function shall then + * create the corresponding Camera instances, store them internally, and return + * true. Otherwise it shall not acquire any media device (or shall release all + * the media devices is has acquired by calling MediaDevice::release()) and + * return false. + * + * If multiple instances of a pipeline are available in the system, the + * PipelineHandler class will be instanciated once per instance, and its match() + * function called for every instance. Each call shall acquire media devices for + * one pipeline instance, until all compatible media devices are exhausted. + * + * If this function returns true, a new instance of the pipeline handler will + * be created and its match() function called, + * + * \return true if media devices have been acquired and camera instances + * created, or false otherwise + */ + +/** + * \fn PipelineHandler::count() + * \brief Retrieve the number of cameras handled by this pipeline handler + * \return the number of cameras that were created by the match() function + */ + +/** + * \fn PipelineHandler::camera(unsigned int id) + * \brief Retrieve one of the cameras handled by this pipeline handler + * \param[in] id the camera index + * \return a pointer to the Camera identified by \a id */ /** * \class PipelineHandlerFactory - * \brief Keep a registry and create instances of available pipeline handlers - * - * The responsibility of the PipelineHandlerFactory is to keep a list - * of all pipelines in the system. Each pipeline handler should register - * it self with the factory using the REGISTER_PIPELINE_HANDLER() macro. + * \brief Registration of PipelineHandler classes and creation of instances + * + * To facilitate discovery and instantiation of PipelineHandler classes, the + * PipelineHandlerFactory class maintains a registry of pipeline handler + * classes. Each PipelineHandler subclass shall register itself using the + * REGISTER_PIPELINE_HANDLER() macro, which will create a corresponding + * instance of a PipelineHandlerFactory subclass and register it with the + * static list of factories. */ /** - * \brief Add a pipeline handler to the global list + * \fn PipelineHandlerFactory::create() + * \brief Create an instance of the PipelineHandler corresponding to the factory * - * \param[in] name Name of the pipeline handler to add - * \param[in] factory Factory to use to construct the pipeline + * This virtual function is implemented by the REGISTER_PIPELINE_HANDLER() macro. + * + * \return a pointer to a newly constructed instance of the PipelineHandler + * subclass corresponding to the factory + */ + +/** + * \brief Add a pipeline handler class to the registry + * \param[in] name Name of the pipeline handler class + * \param[in] factory Factory to use to construct the pipeline handler * - * The caller is responsible to guarantee the uniqueness of the pipeline name. + * The caller is responsible to guarantee the uniqueness of the pipeline handler + * name. */ void PipelineHandlerFactory::registerType(const std::string &name, PipelineHandlerFactory *factory) @@ -68,15 +118,16 @@ void PipelineHandlerFactory::registerType(const std::string &name, } /** - * \brief Create a new pipeline handler and try to match the media devices it requires - * - * \param[in] name Name of the pipeline handler to try + * \brief Create an instance of a pipeline handler if it matches media devices + * present in the system + * \param[in] name Name of the pipeline handler to instantiate * \param[in] enumerator Device enumerator to search for a match for the handler * - * Try to match the media devices pipeline \a name requires against the ones - * registered in \a enumerator. + * This function matches the media devices required by pipeline \a name against + * the devices enumerated by \a enumerator. * - * \return Pipeline handler if a match was found, nullptr otherwise + * \return the newly created pipeline handler instance if a match was found, or + * nullptr otherwise */ PipelineHandler *PipelineHandlerFactory::create(const std::string &name, DeviceEnumerator *enumerator) @@ -100,9 +151,10 @@ PipelineHandler *PipelineHandlerFactory::create(const std::string &name, } /** - * \brief List all names of piepline handlers from the global list + * \brief Retrieve the names of all pipeline handlers registered with the + * factory * - * \return List of registerd pipeline handler names + * \return a list of all registered pipeline handler names */ std::vector PipelineHandlerFactory::handlers() { @@ -116,12 +168,12 @@ std::vector PipelineHandlerFactory::handlers() } /** - * \brief Static global list of pipeline handlers + * \brief Retrieve the list of all pipeline handler factories * * The static factories map is defined inside the function to ensures it gets * initialized on first use, without any dependency on link order. * - * \return Global list of pipeline handlers + * \return the list of pipeline handler factories */ std::map &PipelineHandlerFactory::registry() { @@ -131,12 +183,11 @@ std::map &PipelineHandlerFactory::registr /** * \def REGISTER_PIPELINE_HANDLER - * \brief Register a pipeline handler with the global list - * + * \brief Register a pipeline handler with the pipeline handler factory * \param[in] handler Class name of PipelineHandler derived class to register * - * Register a specific pipeline handler with the global list and make it - * available to try and match devices. + * Register a PipelineHandler subclass with the factory and make it available to + * try and match devices. */ } /* namespace libcamera */