.. SPDX-License-Identifier: CC-BY-SA-4.0
==========
Licenses
==========
TL;DR summary: The libcamera core is covered by the LGPL-2.1-or-later license.
IPA modules included in libcamera are covered by a free software license.
Third-parties may develop IPA modules outside of libcamera and distribute them
under a closed-source license, provided they do not include source code from
the libcamera project.
The libcamera project contains multiple libraries, applications and utilities.
Licenses are expressed through SPDX tags in text-based files that support
comments, and through the .reuse/dep5 file otherwise. A copy of all licenses is
stored in the LICENSES directory.
The following text summarizes the licenses covering the different components of
the project to offer a quick overview for developers. The SPDX and DEP5
information are however authoritative and shall prevail in case of
inconsistencies with the text below.
The libcamera core source code, located under the include/libcamera/ and
src/libcamera/ directories, is fully covered by the LGPL-2.1-or-later license,
which thus covers distribution of the libcamera.so binary. Other files located
in those directories, most notably the meson build files, and various related
build scripts, may be covered by different licenses. None of their source code
is incorporated in the in the libcamera.so binary, they thus don't affect the
distribution terms of the binary.
The IPA modules, located in src/ipa/, are covered by free software licenses
chosen by the module authors. The LGPL-2.1-or-later license is recommended.
Those modules are compiled as separate binaries and dynamically loaded by the
libcamera core at runtime.
The IPA module API is defined in headers located in include/libcamera/ipa/ and
covered by the LGPL-2.1-or-later license. Using the data types (including
classes, structures and enumerations) and macros defined in the IPA module and
libcamera core API headers in IPA modules doesn't extend the LGPL license to
the IPA modules. Third-party closed-source IPA modules are thus permitted,
provided they comply with the licensing requirements of any software they
include or link to.
The libcamera Android camera HAL component is located in src/android/. The
libcamera-specific source code is covered by the LGPL-2.1-or-later license. The
component additionally contains header files and source code, located
respectively in include/android/ and src/android/metadata/, copied verbatim
from Android and covered by the Apache-2.0 license.
The libcamera GStreamer and V4L2 adaptation source code, located respectively
in src/gstreamer/ and src/v4l2/, is fully covered by the LGPL-2.1-or-later
license. Those components are compiled to separate binaries and do not
influence the license of the libcamera core.
The cam and qcam sample applications, as well as the unit tests, located
respectively in src/cam/, src/qcam/ and test/, are covered by the
GPL-2.0-or-later license. qcam additionally includes an icon set covered by the
MIT license. Those applications are compiled to separate binaries and do not
influence the license of the libcamera core.
Additional utilities are located in the utils/ directory and are covered by
various licenses. They are not part of the libcamera core and do not influence
its license.
Finally, copies of various Linux kernel headers are included in include/linux/
to avoid depending on particular versions of those headers being installed in
the system. The Linux kernel headers are covered by their respective license,
including the Linux kernel license syscall exception. Using a copy of those
headers doesn't affect libcamera licensing terms in any way compared to using
the same headers installed in the system from kernel headers packages provided
by Linux distributions.
'>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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* threads.cpp - Threads test
*/
#include <chrono>
#include <iostream>
#include <thread>
#include "thread.h"
#include "test.h"
using namespace std;
using namespace libcamera;
class DelayThread : public Thread
{
public:
DelayThread(chrono::steady_clock::duration duration)
: duration_(duration)
{
}
protected:
void run()
{
this_thread::sleep_for(duration_);
}
private:
chrono::steady_clock::duration duration_;
};
class ThreadTest : public Test
{
protected:
int init()
{
return 0;
}
int run()
{
/* Test Thread() retrieval for the main thread. */
Thread *thread = Thread::current();
if (!thread) {
cout << "Thread::current() failed to main thread"
<< endl;
return TestFail;
}
if (!thread->isRunning()) {
cout << "Main thread is not running" << endl;
return TestFail;
}
/* Test starting the main thread, the test shall not crash. */
thread->start();
/* Test the running state of a custom thread. */
thread = new Thread();
thread->start();
if (!thread->isRunning()) {
cout << "Thread is not running after being started"
<< endl;
return TestFail;
}
thread->exit(0);
thread->wait();
if (thread->isRunning()) {
cout << "Thread is still running after finishing"
<< endl;
return TestFail;
}
delete thread;
/* Test waiting for completion with a timeout. */
thread = new DelayThread(chrono::milliseconds(500));
thread->start();
thread->exit(0);
bool timeout = !thread->wait(chrono::milliseconds(100));
if (!timeout) {
cout << "Waiting for thread didn't time out" << endl;
return TestFail;
}
timeout = !thread->wait(chrono::milliseconds(1000));
if (timeout) {
cout << "Waiting for thread timed out" << endl;
return TestFail;
}
delete thread;
/* Test waiting on a thread that isn't running. */
thread = new Thread();
timeout = !thread->wait();
if (timeout) {
cout << "Waiting for non-started thread timed out" << endl;
return TestFail;
}
thread->start();
thread->exit(0);
thread->wait();
timeout = !thread->wait();
if (timeout) {
cout << "Waiting for already stopped thread timed out" << endl;
return TestFail;
}
return TestPass;
}
void cleanup()
{
}
};
TEST_REGISTER(ThreadTest)
|