src/apps/qcam/assets/feathericons/briefcase.svg


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * semaphore.cpp - General-purpose counting semaphore
 */

#include "semaphore.h"
#include "thread.h"

/**
 * \file semaphore.h
 * \brief General-purpose counting semaphore
 */

namespace libcamera {

/**
 * \class Semaphore
 * \brief General-purpose counting semaphore
 *
 * A semaphore is a locking primitive that protects resources. It is created
 * with an initial number of resources (which may be 0), and offers two
 * primitives to acquire and release resources. The acquire() method tries to
 * acquire a number of resources, and blocks if not enough resources are
 * available until they get released. The release() method releases a number of
 * resources, waking up any consumer blocked on an acquire() call.
 */

/**
 * \brief Construct a semaphore with \a n resources
 * \param[in] n The resource count
 */
Semaphore::Semaphore(unsigned int n)
	: available_(n)
{
}

/**
 * \brief Retrieve the number of available resources
 * \return The number of available resources
 */
unsigned int Semaphore::available()
{
	MutexLocker locker(mutex_);
	return available_;
}

/**
 * \brief Acquire \a n resources
 * \param[in] n The resource count
 *
 * This method attempts to acquire \a n resources. If \a n is higher than the
 * number of available resources, the call will block until enough resources
 * become available.
 */
void Semaphore::acquire(unsigned int n)
{
	MutexLocker locker(mutex_);
	cv_.wait(locker, [&] { return available_ >= n; });
	available_ -= n;
}

/**
 * \brief Try to acquire \a n resources without blocking
 * \param[in] n The resource count
 *
 * This method attempts to acquire \a n resources. If \a n is higher than the
 * number of available resources, it returns false immediately without
 * acquiring any resource. Otherwise it acquires the resources and returns
 * true.
 *
 * \return True if the resources have been acquired, false otherwise
 */
bool Semaphore::tryAcquire(unsigned int n)
{
	MutexLocker locker(mutex_);
	if (available_ < n)
		return false;

	available_ -= n;
	return true;
}

/**
 * \brief Release \a n resources
 * \param[in] n The resource count
 *
 * This method releases \a n resources, increasing the available resource count
 * by \a n. If the number of available resources becomes large enough for any
 * consumer blocked on an acquire() call, those consumers get woken up.
 */
void Semaphore::release(unsigned int n)
{
	{
		MutexLocker locker(mutex_);
		available_ += n;
	}

	cv_.notify_all();
}

} /* namespace libcamera */