index : libcamera/libcamera.git	master
	libcamera official repository	git repository hosting on libcamera.org

summaryrefslogtreecommitdiff

log msg author committer range

path: root/utils/tracepoints

Age	Commit message (Collapse)	Author
2021-12-14	utils: tracepoints: gen-tp-header: Add execute permission	Brian Olson
	The gen-tp-header script does not have execute permissions set on the file. Add the execute permission to ensure that meson runs this script consistently in the same configuration as other scripts, without invoking python itself separately. Signed-off-by: Brian Olson <icic@bolson.org> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org> Signed-off-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
2020-11-03	utils: tracepoints: Add simple statistics script	Paul Elder
	Add a script that scans a trace for IPA call tracepoints, and returns statistics on the time taken for IPA calls. Signed-off-by: Paul Elder <paul.elder@ideasonboard.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
2020-11-03	libcamera: tracing: Implement tracing infrastructure	Paul Elder
	Implement tracing infrastructure in libcamera. It takes .tp files, as required by lttng, and generates a tracepoint header and C file, as lttng requires. meson is updated accordingly to get it to compile with the rest of libcamera. Update the documentation accordingly. Signed-off-by: Paul Elder <paul.elder@ideasonboard.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>

generated by cgit v1.2.1 (git 2.18.0) at 2025-04-13 19:10:08 +0000

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * options.h - cam - Options parsing
 */
#ifndef __CAM_OPTIONS_H__
#define __CAM_OPTIONS_H__

#include <ctype.h>
#include <list>
#include <map>
#include <tuple>
#include <vector>

class KeyValueParser;
class OptionValue;
struct Option;

enum OptionArgument {
	ArgumentNone,
	ArgumentRequired,
	ArgumentOptional,
};

enum OptionType {
	OptionNone,
	OptionInteger,
	OptionString,
	OptionKeyValue,
};

template<typename T>
class OptionsBase
{
public:
	OptionsBase() : valid_(false) {}

	bool empty() const;
	bool valid() const;
	bool isSet(const T &opt) const;
	const OptionValue &operator[](const T &opt) const;

	void invalidate();

private:
	friend class KeyValueParser;
	friend class OptionsParser;

	bool parseValue(const T &opt, const Option &option, const char *value);

	std::map<T, OptionValue> values_;
	bool valid_;
};

class KeyValueParser
{
public:
	class Options : public OptionsBase<std::string>
	{
	};

	KeyValueParser();
	virtual ~KeyValueParser();

	bool addOption(const char *name, OptionType type, const char *help,
		       OptionArgument argument = ArgumentNone);

	virtual Options parse(const char *arguments);

private:
	KeyValueParser(const KeyValueParser &) = delete;
	KeyValueParser &operator=(const KeyValueParser &) = delete;

	friend class OptionsParser;
	unsigned int maxOptionLength() const;
	void usage(int indent);

	std::map<std::string, Option> optionsMap_;
};

class OptionsParser
{
public:
	class Options : public OptionsBase<int>
	{
	};

	OptionsParser();
	~OptionsParser();

	bool addOption(int opt, OptionType type, const char *help,
		       const char *name = nullptr,
		       OptionArgument argument = ArgumentNone,
		       const char *argumentName = nullptr, bool array = false,
		       int parent = 0);
	bool addOption(int opt, KeyValueParser *parser, const char *help,
		       const char *name = nullptr, bool array = false,
		       int parent = 0);

	Options parse(int argc, char *argv[]);
	void usage();

private:
	OptionsParser(const OptionsParser &) = delete;
	OptionsParser &operator=(const OptionsParser &) = delete;

	void usageOptions(const std::list<Option> &options, unsigned int indent);

	std::tuple<OptionsParser::Options *, const Option *>
	childOption(const Option *parent, Options *options);
	bool parseValue(const Option &option, const char *arg, Options *options);

	std::list<Option> options_;
	std::map<unsigned int, Option *> optionsMap_;
};

class OptionValue
{
public:
	enum ValueType {
		ValueNone,
		ValueInteger,
		ValueString,
		ValueKeyValue,
		ValueArray,
	};

	OptionValue();
	OptionValue(int value);
	OptionValue(const char *value);
	OptionValue(const std::string &value);
	OptionValue(const KeyValueParser::Options &value);

	void addValue(const OptionValue &value);

	ValueType type() const { return type_; }
	bool empty() const { return type_ == ValueType::ValueNone; }

	operator int() const;
	operator std::string() const;

	int toInteger() const;
	std::string toString() const;
	const KeyValueParser::Options &toKeyValues() const;
	const std::vector<OptionValue> &toArray() const;

	const OptionsParser::Options &children() const;

private:
	ValueType type_;
	int integer_;
	std::string string_;
	KeyValueParser::Options keyValues_;
	std::vector<OptionValue> array_;
	OptionsParser::Options children_;
};

#endif /* __CAM_OPTIONS_H__ */