mirror of
https://github.com/opencv/opencv.git
synced 2026-07-31 00:03:03 +04:00
adding OpenCV Manager
This commit is contained in:
Andrey Pavlenko
@@ -0,0 +1,186 @@
|
||||
#include "IOpenCVEngine.h"
|
||||
#include "CommonPackageManager.h"
|
||||
#include "HardwareDetector.h"
|
||||
#include <utils/Log.h>
|
||||
#include <algorithm>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
#undef LOG_TAG
|
||||
#define LOG_TAG "CommonPackageManager"
|
||||
|
||||
using namespace std;
|
||||
|
||||
set<string> CommonPackageManager::GetInstalledVersions()
|
||||
{
|
||||
set<string> result;
|
||||
vector<PackageInfo> installed_packages = GetInstalledPackages();
|
||||
|
||||
for (vector<PackageInfo>::const_iterator it = installed_packages.begin(); it != installed_packages.end(); ++it)
|
||||
{
|
||||
string version = it->GetVersion();
|
||||
assert(!version.empty());
|
||||
result.insert(version);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool CommonPackageManager::CheckVersionInstalled(const std::string& version, int platform, int cpu_id)
|
||||
{
|
||||
bool result = false;
|
||||
LOGD("CommonPackageManager::CheckVersionInstalled() begin");
|
||||
PackageInfo target_package(version, platform, cpu_id);
|
||||
LOGD("GetInstalledPackages() call");
|
||||
vector<PackageInfo> packages = GetInstalledPackages();
|
||||
|
||||
for (vector<PackageInfo>::const_iterator it = packages.begin(); it != packages.end(); ++it)
|
||||
{
|
||||
LOGD("Found package: \"%s\"", it->GetFullName().c_str());
|
||||
}
|
||||
|
||||
if (!packages.empty())
|
||||
{
|
||||
result = (packages.end() != find(packages.begin(), packages.end(), target_package));
|
||||
}
|
||||
LOGD("CommonPackageManager::CheckVersionInstalled() end");
|
||||
return result;
|
||||
}
|
||||
|
||||
bool CommonPackageManager::InstallVersion(const std::string& version, int platform, int cpu_id)
|
||||
{
|
||||
LOGD("CommonPackageManager::InstallVersion() begin");
|
||||
PackageInfo package(version, platform, cpu_id);
|
||||
return InstallPackage(package);
|
||||
}
|
||||
|
||||
string CommonPackageManager::GetPackagePathByVersion(const std::string& version, int platform, int cpu_id)
|
||||
{
|
||||
string result;
|
||||
PackageInfo target_package(version, platform, cpu_id);
|
||||
vector<PackageInfo> all_packages = GetInstalledPackages();
|
||||
vector<PackageInfo> packages;
|
||||
|
||||
for (vector<PackageInfo>::iterator it = all_packages.begin(); it != all_packages.end(); ++it)
|
||||
{
|
||||
if (IsVersionCompatible(version, it->GetVersion()))
|
||||
{
|
||||
packages.push_back(*it);
|
||||
}
|
||||
}
|
||||
|
||||
if (!packages.empty())
|
||||
{
|
||||
vector<PackageInfo>::iterator found = find(packages.begin(), packages.end(), target_package);
|
||||
if (packages.end() != found)
|
||||
{
|
||||
result = found->GetInstalationPath();
|
||||
}
|
||||
else
|
||||
{
|
||||
int OptRating = -1;
|
||||
std::vector<std::pair<int, int> >& group = CommonPackageManager::ArmRating;
|
||||
|
||||
if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
|
||||
group = CommonPackageManager::IntelRating;
|
||||
|
||||
int HardwareRating = GetHardwareRating(platform, cpu_id, group);
|
||||
|
||||
if (-1 == HardwareRating)
|
||||
{
|
||||
LOGE("Cannot calculate rating for current hardware platfrom!");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
|
||||
{
|
||||
int PackageRating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), group);
|
||||
if (PackageRating >= 0)
|
||||
{
|
||||
if ((PackageRating <= HardwareRating) && (PackageRating > OptRating))
|
||||
{
|
||||
OptRating = PackageRating;
|
||||
found = it;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ((-1 != OptRating) && (packages.end() != found))
|
||||
{
|
||||
result = found->GetInstalationPath();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
bool CommonPackageManager::IsVersionCompatible(const std::string& target_version, const std::string& package_version)
|
||||
{
|
||||
assert (target_version.size() == 3);
|
||||
assert (package_version.size() == 3);
|
||||
|
||||
bool result = false;
|
||||
|
||||
// major version is the same and minor package version is above or the same as target.
|
||||
if ((package_version[0] == target_version[0]) && (package_version[1] == target_version[1]) && (package_version[2] >= target_version[2]))
|
||||
{
|
||||
result = true;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int CommonPackageManager::GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group)
|
||||
{
|
||||
int result = -1;
|
||||
|
||||
for (size_t i = 0; i < group.size(); i++)
|
||||
{
|
||||
if (group[i] == std::pair<int, int>(platform, cpu_id))
|
||||
{
|
||||
result = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::pair<int, int> > CommonPackageManager::InitArmRating()
|
||||
{
|
||||
std::vector<std::pair<int, int> > result;
|
||||
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv5));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6 | FEATURES_HAS_VFPv3d16));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6 | FEATURES_HAS_VFPv3));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_TEGRA2, ARCH_ARMv7 | FEATURES_HAS_VFPv3));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::pair<int, int> > CommonPackageManager::InitIntelRating()
|
||||
{
|
||||
std::vector<std::pair<int, int> > result;
|
||||
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X64));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSSE3));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE));
|
||||
result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::pair<int, int> > CommonPackageManager::IntelRating = CommonPackageManager::InitIntelRating();
|
||||
std::vector<std::pair<int, int> > CommonPackageManager::ArmRating = InitArmRating();
|
||||
|
||||
CommonPackageManager::~CommonPackageManager()
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#ifndef __COMMON_PACKAGE_MANAGER_H__
|
||||
#define __COMMON_PACKAGE_MANAGER_H__
|
||||
|
||||
#include "IPackageManager.h"
|
||||
#include "PackageInfo.h"
|
||||
#include <set>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
class CommonPackageManager: public IPackageManager
|
||||
{
|
||||
public:
|
||||
std::set<std::string> GetInstalledVersions();
|
||||
bool CheckVersionInstalled(const std::string& version, int platform, int cpu_id);
|
||||
bool InstallVersion(const std::string& version, int platform, int cpu_id);
|
||||
std::string GetPackagePathByVersion(const std::string& version, int platform, int cpu_id);
|
||||
virtual ~CommonPackageManager();
|
||||
|
||||
protected:
|
||||
static std::vector<std::pair<int, int> > ArmRating;
|
||||
static std::vector<std::pair<int, int> > IntelRating;
|
||||
|
||||
static std::vector<std::pair<int, int> > InitArmRating();
|
||||
static std::vector<std::pair<int, int> > InitIntelRating();
|
||||
|
||||
bool IsVersionCompatible(const std::string& target_version, const std::string& package_version);
|
||||
int GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group);
|
||||
|
||||
virtual bool InstallPackage(const PackageInfo& package) = 0;
|
||||
virtual std::vector<PackageInfo> GetInstalledPackages() = 0;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,19 @@
|
||||
#include "NativePackageManager.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
bool NativePackageManager::InstallPackage(const PackageInfo& package)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
vector<PackageInfo> NativePackageManager::GetInstalledPackages()
|
||||
{
|
||||
vector<PackageInfo> result;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
NativePackageManager::~NativePackageManager()
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#ifndef __NATIVE_PACKAGE_MANAGER_STUB_H__
|
||||
#define __NATIVE_PACKAGE_MANAGER_STUB_H__
|
||||
|
||||
#include "IPackageManager.h"
|
||||
#include "CommonPackageManager.h"
|
||||
|
||||
class NativePackageManager: public CommonPackageManager
|
||||
{
|
||||
public:
|
||||
virtual ~NativePackageManager();
|
||||
protected:
|
||||
virtual bool InstallPackage(const PackageInfo& package);
|
||||
virtual std::vector<PackageInfo> GetInstalledPackages();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,391 @@
|
||||
#include "EngineCommon.h"
|
||||
#include "PackageInfo.h"
|
||||
#include "HardwareDetector.h"
|
||||
#include "IOpenCVEngine.h"
|
||||
#include "StringUtils.h"
|
||||
#include <assert.h>
|
||||
#include <vector>
|
||||
#include <utils/Log.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
map<int, string> PackageInfo::InitPlatformNameMap()
|
||||
{
|
||||
map<int, string> result;
|
||||
|
||||
// TODO: Do not forget to add Platrfom constant to HardwareDetector.h
|
||||
result[PLATFORM_TEGRA] = PLATFORM_TEGRA_NAME;
|
||||
result[PLATFORM_TEGRA2] = PLATFORM_TEGRA2_NAME;
|
||||
result[PLATFORM_TEGRA3] = PLATFORM_TEGRA3_NAME;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
const map<int, string> PackageInfo::PlatformNameMap = InitPlatformNameMap();
|
||||
const string PackageInfo::BasePackageName = "org.opencv.lib";
|
||||
|
||||
inline string JoinARMFeatures(int cpu_id)
|
||||
{
|
||||
string result;
|
||||
|
||||
if (FEATURES_HAS_NEON2 & cpu_id)
|
||||
{
|
||||
result = string(FEATURES_HAS_NEON2_NAME);
|
||||
}
|
||||
else if (FEATURES_HAS_NEON & cpu_id)
|
||||
{
|
||||
result = string(FEATURES_HAS_NEON_NAME);
|
||||
}
|
||||
else if (FEATURES_HAS_VFPv3 & cpu_id)
|
||||
{
|
||||
result = string(FEATURES_HAS_VFPv3_NAME);
|
||||
}
|
||||
else if (FEATURES_HAS_VFPv3d16 & cpu_id)
|
||||
{
|
||||
result = string(FEATURES_HAS_VFPv3d16_NAME);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
inline int SplitARMFeatures(const vector<string>& features)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
for (size_t i = 3; i < features.size(); i++)
|
||||
{
|
||||
if (FEATURES_HAS_VFPv3_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_VFPv3;
|
||||
}
|
||||
else if (FEATURES_HAS_VFPv3d16_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_VFPv3d16;
|
||||
}
|
||||
else if (FEATURES_HAS_NEON_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_NEON;
|
||||
}
|
||||
else if (FEATURES_HAS_NEON2_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_NEON2;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
inline string JoinIntelFeatures(int cpu_id)
|
||||
{
|
||||
string result;
|
||||
|
||||
if (FEATURES_HAS_SSSE3 & cpu_id)
|
||||
{
|
||||
result = FEATURES_HAS_SSSE3_NAME;
|
||||
}
|
||||
else if (FEATURES_HAS_SSE2 & cpu_id)
|
||||
{
|
||||
result = FEATURES_HAS_SSE2_NAME;
|
||||
}
|
||||
else if (FEATURES_HAS_SSE & cpu_id)
|
||||
{
|
||||
result = FEATURES_HAS_SSE_NAME;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
inline int SplitIntelFeatures(const vector<string>& features)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
for (size_t i = 3; i < features.size(); i++)
|
||||
{
|
||||
if (FEATURES_HAS_SSSE3_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_SSSE3;
|
||||
}
|
||||
else if (FEATURES_HAS_SSE2_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_SSE2;
|
||||
}
|
||||
else if (FEATURES_HAS_SSE_NAME == features[i])
|
||||
{
|
||||
result |= FEATURES_HAS_SSE;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
inline string SplitVersion(const vector<string>& features, const string& package_version)
|
||||
{
|
||||
string result;
|
||||
|
||||
if ((features.size() > 1) && ('v' == features[1][0]))
|
||||
{
|
||||
result = features[1].substr(1);
|
||||
result += SplitStringVector(package_version, '.')[0];
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Report package name format error
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
inline string JoinPlatform(int platform)
|
||||
{
|
||||
string result;
|
||||
map<int, string>::const_iterator it = PackageInfo::PlatformNameMap.find(platform);
|
||||
|
||||
assert(PackageInfo::PlatformNameMap.end() != it);
|
||||
result = it->second;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
inline int SplitPlatfrom(const vector<string>& features)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
if (features.size() > 2)
|
||||
{
|
||||
string tmp = features[2];
|
||||
if (PLATFORM_TEGRA_NAME == tmp)
|
||||
{
|
||||
result = PLATFORM_TEGRA;
|
||||
}
|
||||
else if (PLATFORM_TEGRA2_NAME == tmp)
|
||||
{
|
||||
result = PLATFORM_TEGRA2;
|
||||
}
|
||||
else if (PLATFORM_TEGRA3_NAME == tmp)
|
||||
{
|
||||
result = PLATFORM_TEGRA3;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Report package name format error
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Package naming convention
|
||||
* All parts of package name seporated by "_" symbol
|
||||
* First part is base namespace.
|
||||
* Second part is version. Version starts from "v" symbol. After "v" symbol version nomber without dot symbol added.
|
||||
* If platform is known third part is platform name
|
||||
* If platform is unknown it is defined by hardware capabilities using pattern: <arch>_<fpu features>_<vectorisation features>_<other features>
|
||||
* Example: armv7_vfpv3_neon, armv7_vfpv3d16_neon
|
||||
*/
|
||||
PackageInfo::PackageInfo(const string& version, int platform, int cpu_id):
|
||||
Version(version),
|
||||
Platform(platform),
|
||||
CpuID(cpu_id),
|
||||
InstallPath("")
|
||||
{
|
||||
FullName = BasePackageName + "_v" + Version.substr(0, Version.size()-1);
|
||||
if (PLATFORM_UNKNOWN != Platform)
|
||||
{
|
||||
FullName += string("_") + JoinPlatform(platform);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ARCH_UNKNOWN != CpuID)
|
||||
{
|
||||
if (ARCH_X86 & CpuID)
|
||||
{
|
||||
LOGD("Found processor with x86 arch");
|
||||
FullName += string("_") + ARCH_X86_NAME;
|
||||
// NOTE: Intel features temporary are not supported
|
||||
//string features = JoinIntelFeatures(CpuID);
|
||||
string features;
|
||||
if (!features.empty())
|
||||
{
|
||||
FullName += string("_") + features;
|
||||
}
|
||||
}
|
||||
if (ARCH_X64 & CpuID)
|
||||
{
|
||||
LOGD("Found processor with x64 arch");
|
||||
// NOTE: Intel features temporary are not supported
|
||||
//FullName += string("_") + ARCH_X64_NAME;
|
||||
//string features = JoinIntelFeatures(CpuID);
|
||||
FullName += string("_") + ARCH_X86_NAME;
|
||||
string features;
|
||||
if (!features.empty())
|
||||
{
|
||||
FullName += string("_") + features;
|
||||
}
|
||||
}
|
||||
if (ARCH_ARMv5 & CpuID)
|
||||
{
|
||||
LOGD("Found processor with ARMv5 arch");
|
||||
FullName += string("_") + ARCH_ARMv5_NAME;
|
||||
string features = JoinARMFeatures(CpuID);
|
||||
if (!features.empty())
|
||||
{
|
||||
FullName += string("_") + features;
|
||||
}
|
||||
}
|
||||
if (ARCH_ARMv6 & CpuID)
|
||||
{
|
||||
LOGD("Found processor with ARMv6 arch");
|
||||
// NOTE: ARM v6 used instead ARM v6
|
||||
//FullName += string("_") + ARCH_ARMv6_NAME;
|
||||
FullName += string("_") + ARCH_ARMv5_NAME;
|
||||
// NOTE: ARM features temporary are not supported
|
||||
//string features = JoinARMFeatures(CpuID);
|
||||
string features;
|
||||
if (!features.empty())
|
||||
{
|
||||
FullName += string("_") + features;
|
||||
}
|
||||
}
|
||||
if (ARCH_ARMv7 & CpuID)
|
||||
{
|
||||
LOGD("Found processor with ARMv7 arch");
|
||||
FullName += string("_") + ARCH_ARMv7_NAME;
|
||||
// NOTE: ARM features temporary are not supported
|
||||
//string features = JoinARMFeatures(CpuID);
|
||||
string features;
|
||||
if (!features.empty())
|
||||
{
|
||||
FullName += string("_") + features;
|
||||
}
|
||||
}
|
||||
if (ARCH_ARMv8 & CpuID)
|
||||
{
|
||||
LOGD("Found processor with ARMv8 arch");
|
||||
FullName += string("_") + ARCH_ARMv8_NAME;
|
||||
string features = JoinARMFeatures(CpuID);
|
||||
if (!features.empty())
|
||||
{
|
||||
FullName += string("_") + features;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGD("Found processor with unknown arch");
|
||||
Version.clear();
|
||||
CpuID = ARCH_UNKNOWN;
|
||||
Platform = PLATFORM_UNKNOWN;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
PackageInfo::PackageInfo(const string& fullname, const string& install_path, const string& package_version):
|
||||
FullName(fullname),
|
||||
InstallPath(install_path)
|
||||
{
|
||||
LOGD("PackageInfo::PackageInfo(\"%s\", \"%s\")", fullname.c_str(), install_path.c_str());
|
||||
|
||||
assert(!fullname.empty());
|
||||
assert(!install_path.empty());
|
||||
|
||||
vector<string> features = SplitStringVector(FullName, '_');
|
||||
|
||||
if (!features.empty() && (BasePackageName == features[0]))
|
||||
{
|
||||
Version = SplitVersion(features, package_version);
|
||||
if (Version.empty())
|
||||
{
|
||||
CpuID = ARCH_UNKNOWN;
|
||||
Platform = PLATFORM_UNKNOWN;
|
||||
return;
|
||||
}
|
||||
|
||||
Platform = SplitPlatfrom(features);
|
||||
if (PLATFORM_UNKNOWN != Platform)
|
||||
{
|
||||
CpuID = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (features.size() < 3)
|
||||
{
|
||||
LOGD("It is not OpenCV library package for this platform");
|
||||
Version.clear();
|
||||
CpuID = ARCH_UNKNOWN;
|
||||
Platform = PLATFORM_UNKNOWN;
|
||||
return;
|
||||
}
|
||||
else if (ARCH_ARMv5_NAME == features[2])
|
||||
{
|
||||
CpuID = ARCH_ARMv5 | SplitARMFeatures(features);
|
||||
}
|
||||
else if (ARCH_ARMv6_NAME == features[2])
|
||||
{
|
||||
CpuID = ARCH_ARMv6 | SplitARMFeatures(features);
|
||||
}
|
||||
else if (ARCH_ARMv7_NAME == features[2])
|
||||
{
|
||||
CpuID = ARCH_ARMv7 | SplitARMFeatures(features);
|
||||
}
|
||||
else if (ARCH_X86_NAME == features[2])
|
||||
{
|
||||
CpuID = ARCH_X86 | SplitIntelFeatures(features);
|
||||
}
|
||||
else if (ARCH_X64_NAME == features[2])
|
||||
{
|
||||
CpuID = ARCH_X64 | SplitIntelFeatures(features);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGD("It is not OpenCV library package for this platform");
|
||||
Version.clear();
|
||||
CpuID = ARCH_UNKNOWN;
|
||||
Platform = PLATFORM_UNKNOWN;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGD("It is not OpenCV library package for this platform");
|
||||
Version.clear();
|
||||
CpuID = ARCH_UNKNOWN;
|
||||
Platform = PLATFORM_UNKNOWN;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
bool PackageInfo::IsValid() const
|
||||
{
|
||||
return !(Version.empty() && (PLATFORM_UNKNOWN == Platform) && (ARCH_UNKNOWN == CpuID));
|
||||
}
|
||||
|
||||
int PackageInfo::GetPlatform() const
|
||||
{
|
||||
return Platform;
|
||||
}
|
||||
|
||||
int PackageInfo::GetCpuID() const
|
||||
{
|
||||
return CpuID;
|
||||
}
|
||||
|
||||
string PackageInfo::GetFullName() const
|
||||
{
|
||||
return FullName;
|
||||
}
|
||||
|
||||
string PackageInfo::GetVersion() const
|
||||
{
|
||||
return Version;
|
||||
}
|
||||
|
||||
string PackageInfo::GetInstalationPath() const
|
||||
{
|
||||
return InstallPath;
|
||||
}
|
||||
|
||||
bool PackageInfo::operator==(const PackageInfo& package) const
|
||||
{
|
||||
return (package.FullName == FullName);
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
#ifndef __PACKAGE_INFO_H__
|
||||
#define __PACKAGE_INFO_H__
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
#define ARCH_X86_NAME "x86"
|
||||
#define ARCH_X64_NAME "x64"
|
||||
#define ARCH_ARMv5_NAME "armv5"
|
||||
#define ARCH_ARMv6_NAME "armv6"
|
||||
#define ARCH_ARMv7_NAME "armv7"
|
||||
#define ARCH_ARMv8_NAME "armv8"
|
||||
|
||||
#define FEATURES_HAS_VFPv3d16_NAME "vfpv3d16"
|
||||
#define FEATURES_HAS_VFPv3_NAME "vfpv3"
|
||||
#define FEATURES_HAS_NEON_NAME "neon"
|
||||
#define FEATURES_HAS_NEON2_NAME "neon2"
|
||||
#define FEATURES_HAS_SSE_NAME "sse"
|
||||
#define FEATURES_HAS_SSE2_NAME "sse2"
|
||||
#define FEATURES_HAS_SSSE3_NAME "ssse3"
|
||||
#define FEATURES_HAS_GPU_NAME "gpu"
|
||||
|
||||
#define PLATFORM_TEGRA_NAME "tegra"
|
||||
#define PLATFORM_TEGRA2_NAME "tegra2"
|
||||
#define PLATFORM_TEGRA3_NAME "tegra3"
|
||||
|
||||
|
||||
class PackageInfo
|
||||
{
|
||||
public:
|
||||
PackageInfo(const std::string& version, int platform, int cpu_id);
|
||||
PackageInfo(const std::string& fullname, const std::string& install_path, const std::string& package_version = "0.0");
|
||||
std::string GetFullName() const;
|
||||
std::string GetVersion() const;
|
||||
int GetPlatform() const;
|
||||
int GetCpuID() const;
|
||||
std::string GetInstalationPath() const;
|
||||
bool operator==(const PackageInfo& package) const;
|
||||
static const std::map<int, std::string> PlatformNameMap;
|
||||
bool IsValid() const;
|
||||
|
||||
protected:
|
||||
static std::map<int, std::string> InitPlatformNameMap();
|
||||
std::string Version;
|
||||
int Platform;
|
||||
int CpuID;
|
||||
std::string FullName;
|
||||
std::string InstallPath;
|
||||
static const std::string BasePackageName;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,32 @@
|
||||
#include "EngineCommon.h"
|
||||
#include "IOpenCVEngine.h"
|
||||
#include "OpenCVEngine.h"
|
||||
#include "IPackageManager.h"
|
||||
#include "NativePackageManager.h"
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <grp.h>
|
||||
#include <binder/IPCThreadState.h>
|
||||
#include <binder/ProcessState.h>
|
||||
#include <binder/IServiceManager.h>
|
||||
#include <utils/Log.h>
|
||||
|
||||
using namespace android;
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
LOGI("OpenCVEngine native service starting");
|
||||
IPackageManager* PackageManager = new NativePackageManager();
|
||||
sp<IBinder> Engine = new OpenCVEngine(PackageManager);
|
||||
|
||||
defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
|
||||
LOGI("OpenCVEngine native service started successfully");
|
||||
ProcessState::self()->startThreadPool();
|
||||
IPCThreadState::self()->joinThreadPool();
|
||||
LOGI("OpenCVEngine native service finished");
|
||||
|
||||
delete PackageManager;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user