/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * main.cpp - cam - The libcamera swiss army knife
 */

#include <iomanip>
#include <iostream>
#include <signal.h>
#include <string.h>

#include <libcamera/libcamera.h>

#include "capture.h"
#include "event_loop.h"
#include "main.h"
#include "options.h"

using namespace libcamera;

class CamApp
{
public:
	CamApp();

	static CamApp *instance();

	int init(int argc, char **argv);
	void cleanup();

	int exec();
	void quit();

private:
	int parseOptions(int argc, char *argv[]);
	int prepareConfig();
	int infoConfiguration();
	int run();

	static CamApp *app_;
	OptionsParser::Options options_;
	CameraManager *cm_;
	std::shared_ptr<Camera> camera_;
	std::unique_ptr<libcamera::CameraConfiguration> config_;
	EventLoop *loop_;
};

CamApp *CamApp::app_ = nullptr;

CamApp::CamApp()
	: cm_(nullptr), camera_(nullptr), config_(nullptr), loop_(nullptr)
{
	CamApp::app_ = this;
}

CamApp *CamApp::instance()
{
	return CamApp::app_;
}

int CamApp::init(int argc, char **argv)
{
	int ret;

	ret = parseOptions(argc, argv);
	if (ret < 0)
		return ret;

	cm_ = CameraManager::instance();

	ret = cm_->start();
	if (ret) {
		std::cout << "Failed to start camera manager: "
			  << strerror(-ret) << std::endl;
		return ret;
	}

	if (options_.isSet(OptCamera)) {
		const std::string &cameraName = options_[OptCamera];
		char *endptr;
		unsigned long index = strtoul(cameraName.c_str(), &endptr, 10);
		if (*endptr == '\0' && index > 0 && index <= cm_->cameras().size())
			camera_ = cm_->cameras()[index - 1];
		else
			camera_ = cm_->get(cameraName);

		if (!camera_) {
			std::cout << "Camera "
				  << std::string(options_[OptCamera])
				  << " not found" << std::endl;
			cm_->stop();
			return -ENODEV;
		}

		if (camera_->acquire()) {
			std::cout << "Failed to acquire camera" << std::endl;
			camera_.reset();
			cm_->stop();
			return -EINVAL;
		}

		std::cout << "Using camera " << camera_->name() << std::endl;

		ret = prepareConfig();
		if (ret)
			return ret;
	}

	loop_ = new EventLoop(cm_->eventDispatcher());

	return 0;
}

void CamApp::cleanup()
{
	delete loop_;
	loop_ = nullptr;

	if (camera_) {
		camera_->release();
		camera_.reset();
	}

	config_.reset();

	cm_->stop();
}

int CamApp::exec()
{
	int ret;

	ret = run();
	cleanup();

	return ret;
}

void CamApp::quit()
{
	if (loop_)
		loop_->exit();
}

int CamApp::parseOptions(int argc, char *argv[])
{
	KeyValueParser streamKeyValue;
	streamKeyValue.addOption("role", OptionString,
				 "Role for the stream (viewfinder, video, still)",
				 ArgumentRequired);
	streamKeyValue.addOption("width", OptionInteger, "Width in pixels",
				 ArgumentRequired);
	streamKeyValue.addOption("height", OptionInteger, "Height in pixels",
				 ArgumentRequired);
	streamKeyValue.addOption("pixelformat", OptionInteger, "Pixel format",
				 ArgumentRequired);

	OptionsParser parser;
	parser.addOption(OptCamera, OptionString,
			 "Specify which camera to operate on, by name or by index", "camera",
			 ArgumentRequired, "camera");
	parser.addOption(OptCapture, OptionNone,
			 "Capture until interrupted by user", "capture");
	parser.addOption(OptFile, OptionString,
			 "Write captured frames to disk\n"
			 "The first '#' character in the file name is expanded to the stream name and frame sequence number.\n"
			 "The default file name is 'frame-#.bin'.",
			 "file", ArgumentOptional, "filename");
	parser.addOption(OptStream, &streamKeyValue,
			 "Set configuration of a camera stream", "stream", true);
	parser.addOption(OptHelp, OptionNone, "Display this help message",
			 "help");
	parser.addOption(OptInfo, OptionNone,
			 "Display information about stream(s)", "info");
	parser.addOption(OptList, OptionNone, "List all cameras", "list");

	options_ = parser.parse(argc, argv);
	if (!options_.valid())
		return -EINVAL;

	if (options_.empty() || options_.isSet(OptHelp)) {
		parser.usage();
		return options_.empty() ? -EINVAL : -EINTR;
	}

	return 0;
}

int CamApp::prepareConfig()
{
	StreamRoles roles;

	if (options_.isSet(OptStream)) {
		const std::vector<OptionValue> &streamOptions =
			options_[OptStream].toArray();

		/* Use roles and get a default configuration. */
		for (auto const &value : streamOptions) {
			KeyValueParser::Options opt = value.toKeyValues();

			if (!opt.isSet("role")) {
				roles.push_back(StreamRole::VideoRecording);
			} else if (opt["role"].toString() == "viewfinder") {
				roles.push_back(StreamRole::Viewfinder);
			} else if (opt["role"].toString() == "video") {
				roles.push_back(StreamRole::VideoRecording);
			} else if (opt["role"].toString() == "still") {
				roles.push_back(StreamRole::StillCapture);
			} else {
				std::cerr << "Unknown stream role "
					  << opt["role"].toString() << std::endl;
				return -EINVAL;
			}
		}
	} else {
		/* If no configuration is provided assume a single video stream. */
		roles.push_back(StreamRole::VideoRecording);
	}

	config_ = camera_->generateConfiguration(roles);
	if (!config_ || config_->size() != roles.size()) {
		std::cerr << "Failed to get default stream configuration"
			  << std::endl;
		return -EINVAL;
	}

	/* Apply configuration if explicitly requested. */
	if (options_.isSet(OptStream)) {
		const std::vector<OptionValue> &streamOptions =
			options_[OptStream].toArray();

		unsigned int i = 0;
		for (auto const &value : streamOptions) {
			KeyValueParser::Options opt = value.toKeyValues();
			StreamConfiguration &cfg = config_->at(i++);

			if (opt.isSet("width"))
				cfg.size.width = opt["width"];

			if (opt.isSet("height"))
				cfg.size.height = opt["height"];

			/* TODO: Translate 4CC string to ID. */
			if (opt.isSet("pixelformat"))
				cfg.pixelFormat = opt["pixelformat"];
		}
	}

	switch (config_->validate()) {
	case CameraConfiguration::Valid:
		break;
	case CameraConfiguration::Adjusted:
		std::cout << "Camera configuration adjusted" << std::endl;
		break;
	case CameraConfiguration::Invalid:
		std::cout << "Camera configuration invalid" << std::endl;
		config_.reset();
		return -EINVAL;
	}

	return 0;
}

int CamApp::infoConfiguration()
{
	if (!config_) {
		std::cout << "Cannot print stream information without a camera"
			  << std::endl;
		return -EINVAL;
	}

	unsigned int index = 0;
	for (const StreamConfiguration &cfg : *config_) {
		std::cout << index << ": " << cfg.toString() << std::endl;

		const StreamFormats &formats = cfg.formats();
		for (unsigned int pixelformat : formats.pixelformats()) {
			std::cout << " * Pixelformat: 0x" << std::hex
				  << std::setw(8) << pixelformat << " "
				  << formats.range(pixelformat).toString()
				  << std::endl;

			for (const Size &size : formats.sizes(pixelformat))
				std::cout << "  - " << size.toString()
					  << std::endl;
		}

		index++;
	}

	return 0;
}

int CamApp::run()
{
	int ret;

	if (options_.isSet(OptList)) {
		std::cout << "Available cameras:" << std::endl;

		unsigned int index = 1;
		<span class="hl com">/* SPDX-License-Identifier: Apache-2.0 */</span>
<span class="hl com">/*</span>
<span class="hl com"> * Copyright 2014 The Android Open Source Project</span>
<span class="hl com"> *</span>
<span class="hl com"> * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);</span>
<span class="hl com"> * you may not use this file except in compliance with the License.</span>
<span class="hl com"> * You may obtain a copy of the License at</span>
<span class="hl com"> *</span>
<span class="hl com"> *      http://www.apache.org/licenses/LICENSE-2.0</span>
<span class="hl com"> *</span>
<span class="hl com"> * Unless required by applicable law or agreed to in writing, software</span>
<span class="hl com"> * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,</span>
<span class="hl com"> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span>
<span class="hl com"> * See the License for the specific language governing permissions and</span>
<span class="hl com"> * limitations under the License.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#ifndef SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H</span>
<span class="hl ppc">#define SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H</span>

<span class="hl ppc">#include &lt;system/camera_vendor_tags.h&gt;</span>

<span class="hl com">/**</span>
<span class="hl com"> * Error codes returned by vendor tags ops operations. These are intended</span>
<span class="hl com"> * to be used by all framework code that uses the return values from the</span>
<span class="hl com"> * vendor operations object.</span>
<span class="hl com"> */</span>
<span class="hl ppc">#define VENDOR_SECTION_NAME_ERR   NULL</span>
<span class="hl ppc">#define VENDOR_TAG_NAME_ERR       NULL</span>
<span class="hl ppc">#define VENDOR_TAG_COUNT_ERR      (-1)</span>
<span class="hl ppc">#define VENDOR_TAG_TYPE_ERR       (-1)</span>

<span class="hl ppc">#ifdef __cplusplus</span>
<span class="hl kwc">extern</span> <span class="hl str">&quot;C&quot;</span> <span class="hl opt">{</span>
<span class="hl ppc">#endif</span>
<span class="hl com">/** **These are private functions for use only by the camera framework.** **/</span>

<span class="hl com">/**</span>
<span class="hl com"> * Set the global vendor tag operations object used to define vendor tag</span>
<span class="hl com"> * structure when parsing camera metadata with functions defined in</span>
<span class="hl com"> * system/media/camera/include/camera_metadata.h.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">int</span> <span class="hl kwd">set_camera_metadata_vendor_ops</span><span class="hl opt">(</span><span class="hl kwb">const</span> vendor_tag_ops_t <span class="hl opt">*</span>query_ops<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Set the global vendor tag cache operations object used to define vendor tag</span>
<span class="hl com"> * structure when parsing camera metadata with functions defined in</span>
<span class="hl com"> * system/media/camera/include/camera_metadata.h.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">int</span> <span class="hl kwd">set_camera_metadata_vendor_cache_ops</span><span class="hl opt">(</span>
        <span class="hl kwb">const struct</span> vendor_tag_cache_ops <span class="hl opt">*</span>query_cache_ops<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Set the vendor id for a particular metadata buffer.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">void</span> <span class="hl kwd">set_camera_metadata_vendor_id</span><span class="hl opt">(</span>camera_metadata_t <span class="hl opt">*</span>meta<span class="hl opt">,</span>
        metadata_vendor_id_t id<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Retrieve the vendor id for a particular metadata buffer.</span>
<span class="hl com"> */</span>
ANDROID_API
metadata_vendor_id_t <span class="hl kwd">get_camera_metadata_vendor_id</span><span class="hl opt">(</span>
        <span class="hl kwb">const</span> camera_metadata_t <span class="hl opt">*</span>meta<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Retrieve the type of a tag. Returns -1 if no such tag is defined.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">int</span> <span class="hl kwd">get_local_camera_metadata_tag_type_vendor_id</span><span class="hl opt">(</span><span class="hl kwb">uint32_t</span> tag<span class="hl opt">,</span>
        metadata_vendor_id_t id<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Retrieve the name of a tag. Returns NULL if no such tag is defined.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwd">get_local_camera_metadata_tag_name_vendor_id</span><span class="hl opt">(</span><span class="hl kwb">uint32_t</span> tag<span class="hl opt">,</span>
        metadata_vendor_id_t id<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Retrieve the name of a tag section. Returns NULL if no such tag is defined.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwd">get_local_camera_metadata_section_name_vendor_id</span><span class="hl opt">(</span><span class="hl kwb">uint32_t</span> tag<span class="hl opt">,</span>
        metadata_vendor_id_t id<span class="hl opt">);</span>

<span class="hl com">/**</span>
<span class="hl com"> * Retrieve the type of a tag. Returns -1 if no such tag is defined.</span>
<span class="hl com"> */</span>
ANDROID_API
<span class="hl kwb">int</span> <span class="hl kwd">get_local_camera_metadata_tag_type_vendor_id</span><span class="hl opt">(</span><span class="hl kwb">uint32_t</span> tag<span class="hl opt">,</span>
        metadata_vendor_id_t id<span class="hl opt">);</span>

<span class="hl ppc">#ifdef __cplusplus</span>
<span class="hl opt">}</span> <span class="hl com">/* extern &quot;C&quot; */</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#endif</span> <span class="hl com">/* SYSTEM_MEDIA_PRIVATE_INCLUDE_CAMERA_METADATA_HIDDEN_H */</span><span class="hl ppc"></span>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.1</a> (<a href='https://git-scm.com/'>git 2.18.0</a>) at 2025-04-27 02:15:50 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>