NekoCWD/libcamera
NekoCWD/libcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 7 Wiki Activity Actions
libcamera/test/serialization/ipa_data_serializer_test.cpp
Laurent Pinchart 626172a16b libcamera: Drop file name from header comment blocks 
Source files in libcamera start by a comment block header, which
includes the file name and a one-line description of the file contents.
While the latter is useful to get a quick overview of the file contents
at a glance, the former is mostly a source of inconvenience. The name in
the comments can easily get out of sync with the file name when files
are renamed, and copy & paste during development have often lead to
incorrect names being used to start with.

Readers of the source code are expected to know which file they're
looking it. Drop the file name from the header comment block.

The change was generated with the following script:

----------------------------------------

dirs="include/libcamera src test utils"

declare -rA patterns=(
	['c']=' \* '
	['cpp']=' \* '
	['h']=' \* '
	['py']='# '
	['sh']='# '
)

for ext in ${!patterns[@]} ; do
	files=$(for dir in $dirs ; do find $dir -name "*.${ext}" ; done)
	pattern=${patterns[${ext}]}

	for file in $files ; do
		name=$(basename ${file})
		sed -i "s/^\(${pattern}\)${name} - /\1/" "$file"
	done
done
----------------------------------------

This misses several files that are out of sync with the comment block
header. Those will be addressed separately and manually.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Daniel Scally <dan.scally@ideasonboard.com>
2024-05-08 22:39:50 +03:00

436 lines
11 KiB
C++
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* Test serializing/deserializing with IPADataSerializer
*/
#include <algorithm>
#include <cxxabi.h>
#include <fcntl.h>
#include <iostream>
#include <limits>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#include <libcamera/base/thread.h>
#include <libcamera/base/timer.h>
#include "libcamera/internal/ipa_data_serializer.h"
#include "serialization_test.h"
#include "test.h"
using namespace std;
using namespace libcamera;
static const ControlInfoMap Controls = ControlInfoMap({
{ &controls::AeEnable, ControlInfo(false, true) },
{ &controls::ExposureTime, ControlInfo(0, 999999) },
{ &controls::AnalogueGain, ControlInfo(1.0f, 32.0f) },
{ &controls::ColourGains, ControlInfo(0.0f, 32.0f) },
{ &controls::Brightness, ControlInfo(-1.0f, 1.0f) },
}, controls::controls);
namespace libcamera {
static bool operator==(const ControlInfoMap &lhs, const ControlInfoMap &rhs)
{
return SerializationTest::equals(lhs, rhs);
}
} /* namespace libcamera */
template<typename T>
int testPodSerdes(T in)
{
std::vector<uint8_t> buf;
std::vector<SharedFD> fds;
std::tie(buf, fds) = IPADataSerializer<T>::serialize(in);
T out = IPADataSerializer<T>::deserialize(buf, fds);
if (in == out)
return TestPass;
char *name = abi::__cxa_demangle(typeid(T).name(), nullptr,
nullptr, nullptr);
cerr << "Deserialized " << name << " doesn't match original" << endl;
free(name);
return TestFail;
}
template<typename T>
int testVectorSerdes(const std::vector<T> &in,
ControlSerializer *cs = nullptr)
{
std::vector<uint8_t> buf;
std::vector<SharedFD> fds;
std::tie(buf, fds) = IPADataSerializer<std::vector<T>>::serialize(in, cs);
std::vector<T> out = IPADataSerializer<std::vector<T>>::deserialize(buf, fds, cs);
if (in == out)
return TestPass;
char *name = abi::__cxa_demangle(typeid(T).name(), nullptr,
nullptr, nullptr);
cerr << "Deserialized std::vector<" << name
<< "> doesn't match original" << endl;
free(name);
return TestFail;
}
template<typename K, typename V>
int testMapSerdes(const std::map<K, V> &in,
ControlSerializer *cs = nullptr)
{
std::vector<uint8_t> buf;
std::vector<SharedFD> fds;
std::tie(buf, fds) = IPADataSerializer<std::map<K, V>>::serialize(in, cs);
std::map<K, V> out = IPADataSerializer<std::map<K, V>>::deserialize(buf, fds, cs);
if (in == out)
return TestPass;
char *nameK = abi::__cxa_demangle(typeid(K).name(), nullptr,
nullptr, nullptr);
char *nameV = abi::__cxa_demangle(typeid(V).name(), nullptr,
nullptr, nullptr);
cerr << "Deserialized std::map<" << nameK << ", " << nameV
<< "> doesn't match original" << endl;
free(nameK);
free(nameV);
return TestFail;
}
class IPADataSerializerTest : public CameraTest, public Test
{
public:
IPADataSerializerTest()
: CameraTest("platform/vimc.0 Sensor B")
{
}
protected:
int init() override
{
return status_;
}
int run() override
{
int ret;
ret = testControls();
if (ret != TestPass)
return ret;
ret = testVector();
if (ret != TestPass)
return ret;
ret = testMap();
if (ret != TestPass)
return ret;
ret = testPod();
if (ret != TestPass)
return ret;
return TestPass;
}
private:
ControlList generateControlList(const ControlInfoMap &infoMap)
{
/* Create a control list with three controls. */
ControlList list(infoMap);
list.set(controls::Brightness, 0.5f);
list.set(controls::Contrast, 1.2f);
list.set(controls::Saturation, 0.2f);
return list;
}
int testControls()
{
ControlSerializer cs(ControlSerializer::Role::Proxy);
const ControlInfoMap &infoMap = camera_->controls();
ControlList list = generateControlList(infoMap);
std::vector<uint8_t> infoMapBuf;
std::tie(infoMapBuf, std::ignore) =
IPADataSerializer<ControlInfoMap>::serialize(infoMap, &cs);
std::vector<uint8_t> listBuf;
std::tie(listBuf, std::ignore) =
IPADataSerializer<ControlList>::serialize(list, &cs);
const ControlInfoMap infoMapOut =
IPADataSerializer<ControlInfoMap>::deserialize(infoMapBuf, &cs);
ControlList listOut = IPADataSerializer<ControlList>::deserialize(listBuf, &cs);
if (!SerializationTest::equals(infoMap, infoMapOut)) {
cerr << "Deserialized map doesn't match original" << endl;
return TestFail;
}
if (!SerializationTest::equals(list, listOut)) {
cerr << "Deserialized list doesn't match original" << endl;
return TestFail;
}
return TestPass;
}
int testVector()
{
ControlSerializer cs(ControlSerializer::Role::Proxy);
/*
* We don't test SharedFD serdes because it dup()s, so we
* can't check for equality.
*/
std::vector<uint8_t> vecUint8 = { 1, 2, 3, 4, 5, 6 };
std::vector<uint16_t> vecUint16 = { 1, 2, 3, 4, 5, 6 };
std::vector<uint32_t> vecUint32 = { 1, 2, 3, 4, 5, 6 };
std::vector<uint64_t> vecUint64 = { 1, 2, 3, 4, 5, 6 };
std::vector<int8_t> vecInt8 = { 1, 2, 3, -4, 5, -6 };
std::vector<int16_t> vecInt16 = { 1, 2, 3, -4, 5, -6 };
std::vector<int32_t> vecInt32 = { 1, 2, 3, -4, 5, -6 };
std::vector<int64_t> vecInt64 = { 1, 2, 3, -4, 5, -6 };
std::vector<float> vecFloat = { 1.1, 2.2, 3.3, -4.4, 5.5, -6.6 };
std::vector<double> vecDouble = { 1.1, 2.2, 3.3, -4.4, 5.5, -6.6 };
std::vector<bool> vecBool = { true, true, false, false, true, false };
std::vector<std::string> vecString = { "foo", "bar", "baz" };
std::vector<ControlInfoMap> vecControlInfoMap = {
camera_->controls(),
Controls,
};
std::vector<uint8_t> buf;
std::vector<SharedFD> fds;
if (testVectorSerdes(vecUint8) != TestPass)
return TestFail;
if (testVectorSerdes(vecUint16) != TestPass)
return TestFail;
if (testVectorSerdes(vecUint32) != TestPass)
return TestFail;
if (testVectorSerdes(vecUint64) != TestPass)
return TestFail;
if (testVectorSerdes(vecInt8) != TestPass)
return TestFail;
if (testVectorSerdes(vecInt16) != TestPass)
return TestFail;
if (testVectorSerdes(vecInt32) != TestPass)
return TestFail;
if (testVectorSerdes(vecInt64) != TestPass)
return TestFail;
if (testVectorSerdes(vecFloat) != TestPass)
return TestFail;
if (testVectorSerdes(vecDouble) != TestPass)
return TestFail;
if (testVectorSerdes(vecBool) != TestPass)
return TestFail;
if (testVectorSerdes(vecString) != TestPass)
return TestFail;
if (testVectorSerdes(vecControlInfoMap, &cs) != TestPass)
return TestFail;
return TestPass;
}
int testMap()
{
ControlSerializer cs(ControlSerializer::Role::Proxy);
/*
* Realistically, only string and integral keys.
* Test simple, complex, and nested compound value.
*/
std::map<uint64_t, std::string> mapUintStr =
{ { 101, "foo" }, { 102, "bar" }, { 103, "baz" } };
std::map<int64_t, std::string> mapIntStr =
{ { 101, "foo" }, { -102, "bar" }, { -103, "baz" } };
std::map<std::string, std::string> mapStrStr =
{ { "a", "foo" }, { "b", "bar" }, { "c", "baz" } };
std::map<uint64_t, ControlInfoMap> mapUintCIM =
{ { 201, camera_->controls() }, { 202, Controls } };
std::map<int64_t, ControlInfoMap> mapIntCIM =
{ { 201, camera_->controls() }, { -202, Controls } };
std::map<std::string, ControlInfoMap> mapStrCIM =
{ { "a", camera_->controls() }, { "b", Controls } };
std::map<uint64_t, std::vector<uint8_t>> mapUintBVec =
{ { 301, { 1, 2, 3 } }, { 302, { 4, 5, 6 } }, { 303, { 7, 8, 9 } } };
std::map<int64_t, std::vector<uint8_t>> mapIntBVec =
{ { 301, { 1, 2, 3 } }, { -302, { 4, 5, 6} }, { -303, { 7, 8, 9 } } };
std::map<std::string, std::vector<uint8_t>> mapStrBVec =
{ { "a", { 1, 2, 3 } }, { "b", { 4, 5, 6 } }, { "c", { 7, 8, 9 } } };
std::vector<uint8_t> buf;
std::vector<SharedFD> fds;
if (testMapSerdes(mapUintStr) != TestPass)
return TestFail;
if (testMapSerdes(mapIntStr) != TestPass)
return TestFail;
if (testMapSerdes(mapStrStr) != TestPass)
return TestFail;
if (testMapSerdes(mapUintCIM, &cs) != TestPass)
return TestFail;
if (testMapSerdes(mapIntCIM, &cs) != TestPass)
return TestFail;
if (testMapSerdes(mapStrCIM, &cs) != TestPass)
return TestFail;
if (testMapSerdes(mapUintBVec) != TestPass)
return TestFail;
if (testMapSerdes(mapIntBVec) != TestPass)
return TestFail;
if (testMapSerdes(mapStrBVec) != TestPass)
return TestFail;
return TestPass;
}
int testPod()
{
uint32_t u32min = std::numeric_limits<uint32_t>::min();
uint32_t u32max = std::numeric_limits<uint32_t>::max();
uint32_t u32one = 1;
int32_t i32min = std::numeric_limits<int32_t>::min();
int32_t i32max = std::numeric_limits<int32_t>::max();
int32_t i32one = 1;
uint64_t u64min = std::numeric_limits<uint64_t>::min();
uint64_t u64max = std::numeric_limits<uint64_t>::max();
uint64_t u64one = 1;
int64_t i64min = std::numeric_limits<int64_t>::min();
int64_t i64max = std::numeric_limits<int64_t>::max();
int64_t i64one = 1;
float flow = std::numeric_limits<float>::lowest();
float fmin = std::numeric_limits<float>::min();
float fmax = std::numeric_limits<float>::max();
float falmostOne = 1 + 1.0e-37;
double dlow = std::numeric_limits<double>::lowest();
double dmin = std::numeric_limits<double>::min();
double dmax = std::numeric_limits<double>::max();
double dalmostOne = 1 + 1.0e-307;
bool t = true;
bool f = false;
std::stringstream ss;
for (unsigned int i = 0; i < (1 << 11); i++)
ss << "0123456789";
std::string strLong = ss.str();
std::string strEmpty = "";
std::vector<uint8_t> buf;
std::vector<SharedFD> fds;
if (testPodSerdes(u32min) != TestPass)
return TestFail;
if (testPodSerdes(u32max) != TestPass)
return TestFail;
if (testPodSerdes(u32one) != TestPass)
return TestFail;
if (testPodSerdes(i32min) != TestPass)
return TestFail;
if (testPodSerdes(i32max) != TestPass)
return TestFail;
if (testPodSerdes(i32one) != TestPass)
return TestFail;
if (testPodSerdes(u64min) != TestPass)
return TestFail;
if (testPodSerdes(u64max) != TestPass)
return TestFail;
if (testPodSerdes(u64one) != TestPass)
return TestFail;
if (testPodSerdes(i64min) != TestPass)
return TestFail;
if (testPodSerdes(i64max) != TestPass)
return TestFail;
if (testPodSerdes(i64one) != TestPass)
return TestFail;
if (testPodSerdes(flow) != TestPass)
return TestFail;
if (testPodSerdes(fmin) != TestPass)
return TestFail;
if (testPodSerdes(fmax) != TestPass)
return TestFail;
if (testPodSerdes(falmostOne) != TestPass)
return TestFail;
if (testPodSerdes(dlow) != TestPass)
return TestFail;
if (testPodSerdes(dmin) != TestPass)
return TestFail;
if (testPodSerdes(dmax) != TestPass)
return TestFail;
if (testPodSerdes(dalmostOne) != TestPass)
return TestFail;
if (testPodSerdes(t) != TestPass)
return TestFail;
if (testPodSerdes(f) != TestPass)
return TestFail;
if (testPodSerdes(strLong) != TestPass)
return TestFail;
if (testPodSerdes(strEmpty) != TestPass)
return TestFail;
return TestPass;
}
};
TEST_REGISTER(IPADataSerializerTest)
Reference in a new issue View git blame Copy permalink