mirrors/akvirtualcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use std::string instead of std::wstring. Removed TestFrame.bmp.

Browse source
This commit is contained in:
Gonzalo Exequiel Pedone 2020-10-06 20:06:54 -03:00
parent f7a1dcd218
commit 1cf50519bc
No known key found for this signature in database
GPG key ID: B8B09E63E9B85BAF
48 changed files with 395 additions and 1110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
Manager/src/cmdparser.cpp
View file

@ -707,13 +707,10 @@ int AkVCam::CmdParserPrivate::showDevices(const StringMap &flags,
"Description" "Description"
}; };
auto columns = table.size(); auto columns = table.size();
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv;
for (auto &device: devices) { for (auto &device: devices) {
table.push_back(device); table.push_back(device);
auto description = table.push_back(this->m_ipcBridge.description(device));
cv.to_bytes(this->m_ipcBridge.description(device));
table.push_back(description);
} }
this->drawTable(table, columns); this->drawTable(table, columns);
@ -733,8 +730,7 @@ int AkVCam::CmdParserPrivate::addDevice(const StringMap &flags,
return -1; return -1;
} }
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv; auto deviceId = this->m_ipcBridge.addDevice(args[1]);
auto deviceId = this->m_ipcBridge.addDevice(cv.from_bytes(args[1]));
if (deviceId.empty()) { if (deviceId.empty()) {
std::cerr << "Failed to create device." << std::endl; std::cerr << "Failed to create device." << std::endl;
@ -810,7 +806,7 @@ int AkVCam::CmdParserPrivate::showDeviceDescription(const StringMap &flags,
return -1; return -1;
} }
std::wcout << this->m_ipcBridge.description(args[1]) << std::endl; std::cout << this->m_ipcBridge.description(args[1]) << std::endl;
return 0; return 0;
} }
@ -836,8 +832,7 @@ int AkVCam::CmdParserPrivate::setDeviceDescription(const AkVCam::StringMap &flag
return -1; return -1;
} }
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv; this->m_ipcBridge.setDescription(deviceId, args[2]);
this->m_ipcBridge.setDescription(deviceId, cv.from_bytes(args[2]));
return 0; return 0;
} }
@ -1492,7 +1487,7 @@ int AkVCam::CmdParserPrivate::picture(const AkVCam::StringMap &flags,
UNUSED(flags); UNUSED(flags);
UNUSED(args); UNUSED(args);
std::wcout << this->m_ipcBridge.picture() << std::endl; std::cout << this->m_ipcBridge.picture() << std::endl;
return 0; return 0;
} }
@ -1508,8 +1503,7 @@ int AkVCam::CmdParserPrivate::setPicture(const AkVCam::StringMap &flags,
return -1; return -1;
} }
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv; this->m_ipcBridge.setPicture(args[1]);
this->m_ipcBridge.setPicture(cv.from_bytes(args[1]));
return 0; return 0;
} }
@ -1591,11 +1585,8 @@ void AkVCam::CmdParserPrivate::loadGenerals(Settings &settings)
{ {
settings.beginGroup("General"); settings.beginGroup("General");
if (settings.contains("default_frame")) { if (settings.contains("default_frame"))
auto defaultFrame = settings.value("default_frame"); this->m_ipcBridge.setPicture(settings.value("default_frame"));
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv;
this->m_ipcBridge.setPicture(cv.from_bytes(defaultFrame));
}
if (settings.contains("loglevel")) { if (settings.contains("loglevel")) {
auto logLevel= settings.value("loglevel"); auto logLevel= settings.value("loglevel");
@ -1742,8 +1733,7 @@ void AkVCam::CmdParserPrivate::createDevice(Settings &settings,
return; return;
} }
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv; auto deviceId = this->m_ipcBridge.addDevice(description);
auto deviceId = this->m_ipcBridge.addDevice(cv.from_bytes(description));
auto supportedFormats = this->m_ipcBridge.supportedPixelFormats(IpcBridge::StreamTypeOutput); auto supportedFormats = this->m_ipcBridge.supportedPixelFormats(IpcBridge::StreamTypeOutput);
for (auto &format: formats) { for (auto &format: formats) {

1
Manager/src/cmdparser.h
View file

@ -28,7 +28,6 @@
namespace AkVCam { namespace AkVCam {
class CmdParserPrivate; class CmdParserPrivate;
using StringVector = std::vector<std::string>; using StringVector = std::vector<std::string>;
using WStringVector = std::vector<std::wstring>;
using StringMap = std::map<std::string, std::string>; using StringMap = std::map<std::string, std::string>;
using ProgramOptionsFunc = std::function<int (const StringMap &flags, using ProgramOptionsFunc = std::function<int (const StringMap &flags,
const StringVector &args)>; const StringVector &args)>;

33
VCamUtils/src/fraction.cpp
View file

@ -73,31 +73,6 @@ AkVCam::Fraction::Fraction(const std::string &str)
} }
} }
AkVCam::Fraction::Fraction(const std::wstring &str)
{
this->d = new FractionPrivate;
this->d->m_num = 0;
this->d->m_den = 1;
auto pos = str.find(L'/');
if (pos == std::wstring::npos) {
auto strCpy = trimmed(str);
this->d->m_num = uint32_t(wcstol(strCpy.c_str(), nullptr, 10));
} else {
auto numStr = trimmed(str.substr(0, pos));
auto denStr = trimmed(str.substr(pos + 1));
this->d->m_num = uint32_t(wcstol(numStr.c_str(), nullptr, 10));
this->d->m_den = uint32_t(wcstol(denStr.c_str(), nullptr, 10));
if (this->d->m_den < 1) {
this->d->m_num = 0;
this->d->m_den = 1;
}
}
}
AkVCam::Fraction::Fraction(const Fraction &other) AkVCam::Fraction::Fraction(const Fraction &other)
{ {
this->d = new FractionPrivate; this->d = new FractionPrivate;
@ -168,11 +143,3 @@ std::string AkVCam::Fraction::toString() const
return ss.str(); return ss.str();
} }
std::wstring AkVCam::Fraction::toWString() const
{
std::wstringstream ss;
ss << this->d->m_num << L'/' << this->d->m_den;
return ss.str();
}

2
VCamUtils/src/fraction.h
View file

@ -35,7 +35,6 @@ namespace AkVCam
Fraction(); Fraction();
Fraction(int64_t num, int64_t den); Fraction(int64_t num, int64_t den);
Fraction(const std::string &str); Fraction(const std::string &str);
Fraction(const std::wstring &str);
Fraction(const Fraction &other); Fraction(const Fraction &other);
virtual ~Fraction(); virtual ~Fraction();
Fraction &operator =(const Fraction &other); Fraction &operator =(const Fraction &other);
@ -48,7 +47,6 @@ namespace AkVCam
int64_t &den(); int64_t &den();
double value() const; double value() const;
std::string toString() const; std::string toString() const;
std::wstring toWString() const;
private: private:
FractionPrivate *d; FractionPrivate *d;

7
VCamUtils/src/image/videoformat.cpp
View file

@ -355,13 +355,6 @@ std::string AkVCam::VideoFormat::stringFromFourcc(AkVCam::FourCC fourcc)
return vf? vf->str: std::string(); return vf? vf->str: std::string();
} }
std::wstring AkVCam::VideoFormat::wstringFromFourcc(AkVCam::FourCC fourcc)
{
auto str = stringFromFourcc(fourcc);
return std::wstring(str.begin(), str.end());
}
AkVCam::VideoFormatPrivate::VideoFormatPrivate(FourCC fourcc, AkVCam::VideoFormatPrivate::VideoFormatPrivate(FourCC fourcc,
int width, int width,
int height, int height,

1
VCamUtils/src/image/videoformat.h
View file

@ -70,7 +70,6 @@ namespace AkVCam
int align=32); int align=32);
static FourCC fourccFromString(const std::string &fourccStr); static FourCC fourccFromString(const std::string &fourccStr);
static std::string stringFromFourcc(FourCC fourcc); static std::string stringFromFourcc(FourCC fourcc);
static std::wstring wstringFromFourcc(FourCC fourcc);
private: private:
VideoFormatPrivate *d; VideoFormatPrivate *d;

10
VCamUtils/src/ipcbridge.h
View file

@ -96,8 +96,8 @@ namespace AkVCam
/* Server & Client */ /* Server & Client */
std::wstring picture() const; std::string picture() const;
void setPicture(const std::wstring &picture); void setPicture(const std::string &picture);
int logLevel() const; int logLevel() const;
void setLogLevel(int logLevel); void setLogLevel(int logLevel);
@ -111,9 +111,9 @@ namespace AkVCam
std::vector<std::string> devices() const; std::vector<std::string> devices() const;
// Return human readable description of the device. // Return human readable description of the device.
std::wstring description(const std::string &deviceId) const; std::string description(const std::string &deviceId) const;
void setDescription(const std::string &deviceId, void setDescription(const std::string &deviceId,
const std::wstring &description); const std::string &description);
// Output pixel formats supported by the driver. // Output pixel formats supported by the driver.
std::vector<PixelFormat> supportedPixelFormats(StreamType type) const; std::vector<PixelFormat> supportedPixelFormats(StreamType type) const;
@ -144,7 +144,7 @@ namespace AkVCam
/* Server */ /* Server */
std::string addDevice(const std::wstring &description); std::string addDevice(const std::string &description);
void removeDevice(const std::string &deviceId); void removeDevice(const std::string &deviceId);
void addFormat(const std::string &deviceId, void addFormat(const std::string &deviceId,
const VideoFormat &format, const VideoFormat &format,

83
VCamUtils/src/utils.cpp
View file

@ -54,50 +54,6 @@ std::string AkVCam::replace(const std::string &str,
return newStr; return newStr;
} }
std::wstring AkVCam::replace(const std::wstring &str,
const std::wstring &from,
const std::wstring &to)
{
auto newStr = str;
for (auto pos = newStr.find(from);
pos != std::wstring::npos;
pos = newStr.find(from))
newStr.replace(pos, from.size(), to);
return newStr;
}
bool AkVCam::isEqualFile(const std::wstring &file1, const std::wstring &file2)
{
if (file1 == file2)
return true;
std::fstream f1;
std::fstream f2;
f1.open(std::string(file1.begin(), file1.end()), std::ios_base::in);
f2.open(std::string(file2.begin(), file2.end()), std::ios_base::in);
if (!f1.is_open() || !f2.is_open())
return false;
const size_t bufferSize = 1024;
char buffer1[bufferSize];
char buffer2[bufferSize];
memset(buffer1, 0, bufferSize);
memset(buffer2, 0, bufferSize);
while (!f1.eof() && !f2.eof()) {
f1.read(buffer1, bufferSize);
f2.read(buffer2, bufferSize);
if (memcmp(buffer1, buffer2, bufferSize) != 0)
return false;
}
return true;
}
std::string AkVCam::trimmed(const std::string &str) std::string AkVCam::trimmed(const std::string &str)
{ {
auto left = uint64_t(str.size()); auto left = uint64_t(str.size());
@ -128,36 +84,6 @@ std::string AkVCam::trimmed(const std::string &str)
return str.substr(size_t(left), strippedLen); return str.substr(size_t(left), strippedLen);
} }
std::wstring AkVCam::trimmed(const std::wstring &str)
{
auto left = uint64_t(str.size());
auto right = uint64_t(str.size());
for (size_t i = 0; i < str.size(); i++)
if (!iswspace(str[i])) {
left = uint64_t(i);
break;
}
auto strippedLen = str.size();
if (left == str.size()) {
strippedLen = 0;
} else {
for (int64_t i = str.size() - 1; i >= 0; i--)
if (!iswspace(str[size_t(i)])) {
right = uint64_t(i);
break;
}
strippedLen = size_t(right - left + 1);
}
return str.substr(size_t(left), strippedLen);
}
std::string AkVCam::fill(const std::string &str, size_t maxSize) std::string AkVCam::fill(const std::string &str, size_t maxSize)
{ {
std::stringstream ss; std::stringstream ss;
@ -167,15 +93,6 @@ std::string AkVCam::fill(const std::string &str, size_t maxSize)
return ss.str(); return ss.str();
} }
std::wstring AkVCam::fill(const std::wstring &str, size_t maxSize)
{
std::wstringstream ss;
std::vector<wchar_t> spaces(maxSize, ' ');
ss << str << std::wstring(spaces.data(), maxSize - str.size());
return ss.str();
}
std::string AkVCam::join(const std::vector<std::string> &strs, std::string AkVCam::join(const std::vector<std::string> &strs,
const std::string &separator) const std::string &separator)
{ {

6
VCamUtils/src/utils.h
View file

@ -147,14 +147,8 @@ namespace AkVCam
std::string replace(const std::string &str, std::string replace(const std::string &str,
const std::string &from, const std::string &from,
const std::string &to); const std::string &to);
std::wstring replace(const std::wstring &str,
const std::wstring &from,
const std::wstring &to);
bool isEqualFile(const std::wstring &file1, const std::wstring &file2);
std::string trimmed(const std::string &str); std::string trimmed(const std::string &str);
std::wstring trimmed(const std::wstring &str);
std::string fill(const std::string &str, size_t maxSize); std::string fill(const std::string &str, size_t maxSize);
std::wstring fill(const std::wstring &str, size_t maxSize);
std::string join(const std::vector<std::string> &strs, std::string join(const std::vector<std::string> &strs,
const std::string &separator); const std::string &separator);
std::vector<std::string> split(const std::string &str, char separator); std::vector<std::string> split(const std::string &str, char separator);

49
cmio/PlatformUtils/src/preferences.cpp
View file

@ -74,19 +74,6 @@ void AkVCam::Preferences::write(const std::string &key,
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID); CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
} }
void AkVCam::Preferences::write(const std::string &key,
const std::wstring &value)
{
AkLogFunction();
AkLogInfo() << "Writing: "
<< key
<< " = "
<< std::string(value.begin(), value.end()) << std::endl;
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
void AkVCam::Preferences::write(const std::string &key, int value) void AkVCam::Preferences::write(const std::string &key, int value)
{ {
AkLogFunction(); AkLogFunction();
@ -147,24 +134,6 @@ std::string AkVCam::Preferences::readString(const std::string &key,
return value; return value;
} }
std::wstring AkVCam::Preferences::readWString(const std::string &key,
const std::wstring &defaultValue)
{
AkLogFunction();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFStringRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
auto value = defaultValue;
if (cfValue) {
value = wstringFromCFType(cfValue);
CFRelease(cfValue);
}
return value;
}
int AkVCam::Preferences::readInt(const std::string &key, int defaultValue) int AkVCam::Preferences::readInt(const std::string &key, int defaultValue)
{ {
AkLogFunction(); AkLogFunction();
@ -284,7 +253,7 @@ void AkVCam::Preferences::sync()
CFPreferencesAppSynchronize(PREFERENCES_ID); CFPreferencesAppSynchronize(PREFERENCES_ID);
} }
std::string AkVCam::Preferences::addDevice(const std::wstring &description) std::string AkVCam::Preferences::addDevice(const std::string &description)
{ {
AkLogFunction(); AkLogFunction();
auto path = createDevicePath(); auto path = createDevicePath();
@ -303,14 +272,14 @@ std::string AkVCam::Preferences::addDevice(const std::wstring &description)
return path; return path;
} }
std::string AkVCam::Preferences::addCamera(const std::wstring &description, std::string AkVCam::Preferences::addCamera(const std::string &description,
const std::vector<VideoFormat> &formats) const std::vector<VideoFormat> &formats)
{ {
return addCamera("", description, formats); return addCamera("", description, formats);
} }
std::string AkVCam::Preferences::addCamera(const std::string &path, std::string AkVCam::Preferences::addCamera(const std::string &path,
const std::wstring &description, const std::string &description,
const std::vector<VideoFormat> &formats) const std::vector<VideoFormat> &formats)
{ {
AkLogFunction(); AkLogFunction();
@ -433,18 +402,18 @@ bool AkVCam::Preferences::cameraExists(const std::string &path)
return false; return false;
} }
std::wstring AkVCam::Preferences::cameraDescription(size_t cameraIndex) std::string AkVCam::Preferences::cameraDescription(size_t cameraIndex)
{ {
if (cameraIndex >= camerasCount()) if (cameraIndex >= camerasCount())
return {}; return {};
return readWString("cameras." return readString("cameras."
+ std::to_string(cameraIndex) + std::to_string(cameraIndex)
+ ".description"); + ".description");
} }
void AkVCam::Preferences::cameraSetDescription(size_t cameraIndex, void AkVCam::Preferences::cameraSetDescription(size_t cameraIndex,
const std::wstring &description) const std::string &description)
{ {
if (cameraIndex >= camerasCount()) if (cameraIndex >= camerasCount())
return; return;
@ -606,12 +575,12 @@ void AkVCam::Preferences::cameraSetControlValue(size_t cameraIndex,
sync(); sync();
} }
std::wstring AkVCam::Preferences::picture() std::string AkVCam::Preferences::picture()
{ {
return readWString("picture"); return readString("picture");
} }
void AkVCam::Preferences::setPicture(const std::wstring &picture) void AkVCam::Preferences::setPicture(const std::string &picture)
{ {
write("picture", picture); write("picture", picture);
sync(); sync();

17
cmio/PlatformUtils/src/preferences.h
View file

@ -35,15 +35,12 @@ namespace AkVCam
void write(const std::string &key, void write(const std::string &key,
const std::shared_ptr<CFTypeRef> &value); const std::shared_ptr<CFTypeRef> &value);
void write(const std::string &key, const std::string &value); void write(const std::string &key, const std::string &value);
void write(const std::string &key, const std::wstring &value);
void write(const std::string &key, int value); void write(const std::string &key, int value);
void write(const std::string &key, double value); void write(const std::string &key, double value);
void write(const std::string &key, std::vector<std::string> &value); void write(const std::string &key, std::vector<std::string> &value);
std::shared_ptr<CFTypeRef> read(const std::string &key); std::shared_ptr<CFTypeRef> read(const std::string &key);
std::string readString(const std::string &key, std::string readString(const std::string &key,
const std::string &defaultValue={}); const std::string &defaultValue={});
std::wstring readWString(const std::string &key,
const std::wstring &defaultValue={});
int readInt(const std::string &key, int defaultValue=0); int readInt(const std::string &key, int defaultValue=0);
double readDouble(const std::string &key, double defaultValue=0.0); double readDouble(const std::string &key, double defaultValue=0.0);
bool readBool(const std::string &key, bool defaultValue=false); bool readBool(const std::string &key, bool defaultValue=false);
@ -54,20 +51,20 @@ namespace AkVCam
void move(const std::string &keyFrom, const std::string &keyTo); void move(const std::string &keyFrom, const std::string &keyTo);
void moveAll(const std::string &keyFrom, const std::string &keyTo); void moveAll(const std::string &keyFrom, const std::string &keyTo);
void sync(); void sync();
std::string addDevice(const std::wstring &description); std::string addDevice(const std::string &description);
std::string addCamera(const std::wstring &description, std::string addCamera(const std::string &description,
const std::vector<VideoFormat> &formats); const std::vector<VideoFormat> &formats);
std::string addCamera(const std::string &path, std::string addCamera(const std::string &path,
const std::wstring &description, const std::string &description,
const std::vector<VideoFormat> &formats); const std::vector<VideoFormat> &formats);
void removeCamera(const std::string &path); void removeCamera(const std::string &path);
size_t camerasCount(); size_t camerasCount();
std::string createDevicePath(); std::string createDevicePath();
int cameraFromPath(const std::string &path); int cameraFromPath(const std::string &path);
bool cameraExists(const std::string &path); bool cameraExists(const std::string &path);
std::wstring cameraDescription(size_t cameraIndex); std::string cameraDescription(size_t cameraIndex);
void cameraSetDescription(size_t cameraIndex, void cameraSetDescription(size_t cameraIndex,
const std::wstring &description); const std::string &description);
std::string cameraPath(size_t cameraIndex); std::string cameraPath(size_t cameraIndex);
size_t formatsCount(size_t cameraIndex); size_t formatsCount(size_t cameraIndex);
VideoFormat cameraFormat(size_t cameraIndex, size_t formatIndex); VideoFormat cameraFormat(size_t cameraIndex, size_t formatIndex);
@ -83,8 +80,8 @@ namespace AkVCam
void cameraSetControlValue(size_t cameraIndex, void cameraSetControlValue(size_t cameraIndex,
const std::string &key, const std::string &key,
int value); int value);
std::wstring picture(); std::string picture();
void setPicture(const std::wstring &picture); void setPicture(const std::string &picture);
int logLevel(); int logLevel();
void setLogLevel(int logLevel); void setLogLevel(int logLevel);
} }

49
cmio/PlatformUtils/src/utils.cpp
View file

@ -122,21 +122,6 @@ std::shared_ptr<CFTypeRef> AkVCam::cfTypeFromStd(const std::string &str)
}); });
} }
std::shared_ptr<CFTypeRef> AkVCam::cfTypeFromStd(const std::wstring &str)
{
auto ref =
new CFTypeRef(CFStringCreateWithBytes(kCFAllocatorDefault,
reinterpret_cast<const UInt8 *>(str.c_str()),
CFIndex(str.size() * sizeof(wchar_t)),
kCFStringEncodingUTF32LE,
false));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::shared_ptr<CFTypeRef> AkVCam::cfTypeFromStd(int num) std::shared_ptr<CFTypeRef> AkVCam::cfTypeFromStd(int num)
{ {
auto ref = auto ref =
@ -192,40 +177,6 @@ std::string AkVCam::stringFromCFType(CFTypeRef cfType)
return str; return str;
} }
std::wstring AkVCam::wstringFromCFType(CFTypeRef cfType)
{
auto len = CFStringGetLength(CFStringRef(cfType));
auto range = CFRangeMake(0, len);
CFIndex bufferLen = 0;
auto converted = CFStringGetBytes(CFStringRef(cfType),
range,
kCFStringEncodingUTF32LE,
0,
false,
nullptr,
0,
&bufferLen);
if (converted < 1 || bufferLen < 1)
return {};
wchar_t cstr[bufferLen];
converted = CFStringGetBytes(CFStringRef(cfType),
range,
kCFStringEncodingUTF32LE,
0,
false,
reinterpret_cast<UInt8 *>(cstr),
bufferLen,
nullptr);
if (converted < 1)
return {};
return std::wstring(cstr, size_t(len));
}
std::string AkVCam::realPath(const std::string &path) std::string AkVCam::realPath(const std::string &path)
{ {
char resolvedPath[PATH_MAX]; char resolvedPath[PATH_MAX];

2
cmio/PlatformUtils/src/utils.h
View file

@ -36,11 +36,9 @@ namespace AkVCam
FourCharCode formatToCM(PixelFormat format); FourCharCode formatToCM(PixelFormat format);
PixelFormat formatFromCM(FourCharCode format); PixelFormat formatFromCM(FourCharCode format);
std::shared_ptr<CFTypeRef> cfTypeFromStd(const std::string &str); std::shared_ptr<CFTypeRef> cfTypeFromStd(const std::string &str);
std::shared_ptr<CFTypeRef> cfTypeFromStd(const std::wstring &str);
std::shared_ptr<CFTypeRef> cfTypeFromStd(int num); std::shared_ptr<CFTypeRef> cfTypeFromStd(int num);
std::shared_ptr<CFTypeRef> cfTypeFromStd(double num); std::shared_ptr<CFTypeRef> cfTypeFromStd(double num);
std::string stringFromCFType(CFTypeRef cfType); std::string stringFromCFType(CFTypeRef cfType);
std::wstring wstringFromCFType(CFTypeRef cfType);
std::string realPath(const std::string &path); std::string realPath(const std::string &path);
VideoFrame loadPicture(const std::string &fileName); VideoFrame loadPicture(const std::string &fileName);
} }

13
cmio/VCamIPC/src/ipcbridge.mm
View file

@ -110,12 +110,12 @@ AkVCam::IpcBridge::~IpcBridge()
delete this->d; delete this->d;
} }
std::wstring AkVCam::IpcBridge::picture() const std::string AkVCam::IpcBridge::picture() const
{ {
return Preferences::picture(); return Preferences::picture();
} }
void AkVCam::IpcBridge::setPicture(const std::wstring &picture) void AkVCam::IpcBridge::setPicture(const std::string &picture)
{ {
AkLogFunction(); AkLogFunction();
Preferences::setPicture(picture); Preferences::setPicture(picture);
@ -123,10 +123,9 @@ void AkVCam::IpcBridge::setPicture(const std::wstring &picture)
if (!this->d->m_serverMessagePort) if (!this->d->m_serverMessagePort)
return; return;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv;
auto dictionary = xpc_dictionary_create(nullptr, nullptr, 0); auto dictionary = xpc_dictionary_create(nullptr, nullptr, 0);
xpc_dictionary_set_int64(dictionary, "message", AKVCAM_ASSISTANT_MSG_PICTURE_UPDATED); xpc_dictionary_set_int64(dictionary, "message", AKVCAM_ASSISTANT_MSG_PICTURE_UPDATED);
xpc_dictionary_set_string(dictionary, "picture", cv.to_bytes(picture).c_str()); xpc_dictionary_set_string(dictionary, "picture", picture.c_str());
xpc_connection_send_message(this->d->m_serverMessagePort, dictionary); xpc_connection_send_message(this->d->m_serverMessagePort, dictionary);
xpc_release(dictionary); xpc_release(dictionary);
} }
@ -287,7 +286,7 @@ std::vector<std::string> AkVCam::IpcBridge::devices() const
return devices; return devices;
} }
std::wstring AkVCam::IpcBridge::description(const std::string &deviceId) const std::string AkVCam::IpcBridge::description(const std::string &deviceId) const
{ {
AkLogFunction(); AkLogFunction();
auto cameraIndex = Preferences::cameraFromPath(deviceId); auto cameraIndex = Preferences::cameraFromPath(deviceId);
@ -299,7 +298,7 @@ std::wstring AkVCam::IpcBridge::description(const std::string &deviceId) const
} }
void AkVCam::IpcBridge::setDescription(const std::string &deviceId, void AkVCam::IpcBridge::setDescription(const std::string &deviceId,
const std::wstring &description) const std::string &description)
{ {
AkLogFunction(); AkLogFunction();
auto cameraIndex = Preferences::cameraFromPath(deviceId); auto cameraIndex = Preferences::cameraFromPath(deviceId);
@ -521,7 +520,7 @@ std::string AkVCam::IpcBridge::clientExe(uint64_t pid) const
return {path}; return {path};
} }
std::string AkVCam::IpcBridge::addDevice(const std::wstring &description) std::string AkVCam::IpcBridge::addDevice(const std::string &description)
{ {
return Preferences::addDevice(description); return Preferences::addDevice(description);
} }

33
cmio/VirtualCamera/src/objectproperties.cpp
View file

@ -31,7 +31,6 @@ namespace AkVCam
PropertyTypeFloat64, PropertyTypeFloat64,
PropertyTypePidT, PropertyTypePidT,
PropertyTypeString, PropertyTypeString,
PropertyTypeWString,
PropertyTypeObjectVector, PropertyTypeObjectVector,
PropertyTypeObjectPtrVector, PropertyTypeObjectPtrVector,
PropertyTypeVideoFormat, PropertyTypeVideoFormat,
@ -55,7 +54,6 @@ namespace AkVCam
} num; } num;
std::string str; std::string str;
std::wstring wstr;
std::vector<Object *> objects; std::vector<Object *> objects;
std::vector<ObjectPtr> objectsPtr; std::vector<ObjectPtr> objectsPtr;
std::vector<VideoFormat> videoFormats; std::vector<VideoFormat> videoFormats;
@ -118,17 +116,6 @@ bool AkVCam::ObjectProperties::setProperty(UInt32 property,
return true; return true;
} }
bool AkVCam::ObjectProperties::setProperty(UInt32 property,
const std::wstring &value,
bool isSettable)
{
this->d->m_properties[property].type = PropertyTypeWString;
this->d->m_properties[property].isSettable = isSettable;
this->d->m_properties[property].wstr = value;
return true;
}
bool AkVCam::ObjectProperties::setProperty(UInt32 property, bool AkVCam::ObjectProperties::setProperty(UInt32 property,
UInt32 value, UInt32 value,
bool isSettable) bool isSettable)
@ -460,26 +447,6 @@ bool AkVCam::ObjectProperties::getProperty(UInt32 property,
break; break;
case PropertyTypeWString:
if (dataUsed) {
*dataUsed = sizeof(CFStringRef);
if (data)
ok = dataSize == *dataUsed;
}
if (ok && data) {
auto value = this->d->m_properties[property].wstr;
*static_cast<CFStringRef *>(data) =
CFStringCreateWithBytes(kCFAllocatorDefault,
reinterpret_cast<const UInt8 *>(value.c_str()),
CFIndex(value.size() * sizeof(wchar_t)),
kCFStringEncodingUTF32LE,
false);
}
break;
case PropertyTypeObjectVector: { case PropertyTypeObjectVector: {
auto &objects = this->d->m_properties[property].objects; auto &objects = this->d->m_properties[property].objects;
auto objectList = static_cast<CMIOObjectID *>(data); auto objectList = static_cast<CMIOObjectID *>(data);

3
cmio/VirtualCamera/src/objectproperties.h
View file

@ -49,9 +49,6 @@ namespace AkVCam
bool setProperty(UInt32 property, bool setProperty(UInt32 property,
const std::string &value, const std::string &value,
bool isSettable=true); bool isSettable=true);
bool setProperty(UInt32 property,
const std::wstring &value,
bool isSettable=true);
bool setProperty(UInt32 property, bool setProperty(UInt32 property,
UInt32 value, UInt32 value,
bool isSettable=true); bool isSettable=true);

2
cmio/VirtualCamera/src/plugininterface.cpp
View file

@ -373,7 +373,7 @@ void AkVCam::PluginInterface::removeListener(void *userData,
} }
bool AkVCam::PluginInterface::createDevice(const std::string &deviceId, bool AkVCam::PluginInterface::createDevice(const std::string &deviceId,
const std::wstring &description, const std::string &description,
const std::vector<VideoFormat> &formats) const std::vector<VideoFormat> &formats)
{ {
AkLogFunction(); AkLogFunction();

2
cmio/VirtualCamera/src/plugininterface.h
View file

@ -68,7 +68,7 @@ namespace AkVCam
static void removeListener(void *userData, static void removeListener(void *userData,
const std::string &deviceId); const std::string &deviceId);
bool createDevice(const std::string &deviceId, bool createDevice(const std::string &deviceId,
const std::wstring &description, const std::string &description,
const std::vector<VideoFormat> &formats); const std::vector<VideoFormat> &formats);
void destroyDevice(const std::string &deviceId); void destroyDevice(const std::string &deviceId);

6
cmio/VirtualCamera/src/stream.cpp
View file

@ -79,10 +79,8 @@ AkVCam::Stream::Stream(bool registerObject,
this->m_classID = kCMIOStreamClassID; this->m_classID = kCMIOStreamClassID;
auto picture = Preferences::picture(); auto picture = Preferences::picture();
if (!picture.empty()) { if (!picture.empty())
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv; this->d->m_testFrame = loadPicture(picture);
this->d->m_testFrame = loadPicture(cv.to_bytes(picture));
}
this->d->m_clock = this->d->m_clock =
std::make_shared<Clock>("CMIO::VirtualCamera::Stream", std::make_shared<Clock>("CMIO::VirtualCamera::Stream",

2
dshow/Assistant/src/main.cpp
View file

@ -55,7 +55,7 @@ int main(int argc, char **argv)
AkLogInfo() << "Setting service dispatcher" << std::endl; AkLogInfo() << "Setting service dispatcher" << std::endl;
WCHAR serviceName[] = TEXT(DSHOW_PLUGIN_ASSISTANT_NAME); TCHAR serviceName[] = TEXT(DSHOW_PLUGIN_ASSISTANT_NAME);
SERVICE_TABLE_ENTRY serviceTable[] = { SERVICE_TABLE_ENTRY serviceTable[] = {
{serviceName, serviceMain}, {serviceName, serviceMain},
{nullptr , nullptr } {nullptr , nullptr }

8
dshow/Assistant/src/service.cpp
View file

@ -102,7 +102,7 @@ AkVCam::Service::~Service()
BOOL AkVCam::Service::install() BOOL AkVCam::Service::install()
{ {
AkLogFunction(); AkLogFunction();
WCHAR fileName[MAX_PATH]; TCHAR fileName[MAX_PATH];
if (!GetModuleFileName(nullptr, fileName, MAX_PATH)) { if (!GetModuleFileName(nullptr, fileName, MAX_PATH)) {
AkLogError() << "Can't read module file name" << std::endl; AkLogError() << "Can't read module file name" << std::endl;
@ -142,7 +142,7 @@ BOOL AkVCam::Service::install()
// Add detailed description to the service. // Add detailed description to the service.
SERVICE_DESCRIPTION serviceDescription; SERVICE_DESCRIPTION serviceDescription;
WCHAR description[] = TEXT(DSHOW_PLUGIN_DESCRIPTION_EXT); TCHAR description[] = TEXT(DSHOW_PLUGIN_DESCRIPTION_EXT);
serviceDescription.lpDescription = description; serviceDescription.lpDescription = description;
auto result = auto result =
ChangeServiceConfig2(service, ChangeServiceConfig2(service,
@ -150,7 +150,7 @@ BOOL AkVCam::Service::install()
&serviceDescription); &serviceDescription);
// Configure the service so it will restart if fail. // Configure the service so it will restart if fail.
WCHAR rebootMsg[] = L"Service failed restarting..."; TCHAR rebootMsg[] = TEXT("Service failed restarting...");
std::vector<SC_ACTION> actions { std::vector<SC_ACTION> actions {
{SC_ACTION_RESTART, 5000} {SC_ACTION_RESTART, 5000}
@ -264,7 +264,7 @@ AkVCam::ServicePrivate::ServicePrivate()
0 0
}; };
this->m_statusHandler = nullptr; this->m_statusHandler = nullptr;
this->m_messageServer.setPipeName(L"\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME_L); this->m_messageServer.setPipeName("\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME);
this->m_messageServer.setHandlers({ this->m_messageServer.setHandlers({
{AKVCAM_ASSISTANT_MSG_FRAME_READY , AKVCAM_BIND_FUNC(ServicePrivate::frameReady) }, {AKVCAM_ASSISTANT_MSG_FRAME_READY , AKVCAM_BIND_FUNC(ServicePrivate::frameReady) },
{AKVCAM_ASSISTANT_MSG_PICTURE_UPDATED , AKVCAM_BIND_FUNC(ServicePrivate::pictureUpdated) }, {AKVCAM_ASSISTANT_MSG_PICTURE_UPDATED , AKVCAM_BIND_FUNC(ServicePrivate::pictureUpdated) },

52
dshow/PlatformUtils/src/messageserver.cpp
View file

@ -34,7 +34,7 @@ namespace AkVCam
{ {
public: public:
MessageServer *self; MessageServer *self;
std::wstring m_pipeName; std::string m_pipeName;
std::map<uint32_t, MessageHandler> m_handlers; std::map<uint32_t, MessageHandler> m_handlers;
MessageServer::ServerMode m_mode {MessageServer::ServerModeReceive}; MessageServer::ServerMode m_mode {MessageServer::ServerModeReceive};
MessageServer::PipeState m_pipeState {MessageServer::PipeStateGone}; MessageServer::PipeState m_pipeState {MessageServer::PipeStateGone};
@ -70,17 +70,17 @@ AkVCam::MessageServer::~MessageServer()
delete this->d; delete this->d;
} }
std::wstring AkVCam::MessageServer::pipeName() const std::string AkVCam::MessageServer::pipeName() const
{ {
return this->d->m_pipeName; return this->d->m_pipeName;
} }
std::wstring &AkVCam::MessageServer::pipeName() std::string &AkVCam::MessageServer::pipeName()
{ {
return this->d->m_pipeName; return this->d->m_pipeName;
} }
void AkVCam::MessageServer::setPipeName(const std::wstring &pipeName) void AkVCam::MessageServer::setPipeName(const std::string &pipeName)
{ {
this->d->m_pipeName = pipeName; this->d->m_pipeName = pipeName;
} }
@ -169,29 +169,17 @@ BOOL AkVCam::MessageServer::sendMessage(const std::string &pipeName,
Message *message, Message *message,
uint32_t timeout) uint32_t timeout)
{ {
return sendMessage(std::wstring(pipeName.begin(), pipeName.end()), return sendMessage(pipeName, *message, message, timeout);
message,
timeout);
} }
BOOL AkVCam::MessageServer::sendMessage(const std::wstring &pipeName, BOOL AkVCam::MessageServer::sendMessage(const std::string &pipeName,
Message *message,
uint32_t timeout)
{
return sendMessage(pipeName,
*message,
message,
timeout);
}
BOOL AkVCam::MessageServer::sendMessage(const std::wstring &pipeName,
const Message &messageIn, const Message &messageIn,
Message *messageOut, Message *messageOut,
uint32_t timeout) uint32_t timeout)
{ {
DWORD bytesTransferred = 0; DWORD bytesTransferred = 0;
return CallNamedPipe(pipeName.c_str(), return CallNamedPipeA(pipeName.c_str(),
const_cast<Message *>(&messageIn), const_cast<Message *>(&messageIn),
DWORD(sizeof(Message)), DWORD(sizeof(Message)),
messageOut, messageOut,
@ -217,12 +205,12 @@ bool AkVCam::MessageServerPrivate::startReceive(bool wait)
* *
* https://msdn.microsoft.com/en-us/library/windows/desktop/aa379570(v=vs.85).aspx * https://msdn.microsoft.com/en-us/library/windows/desktop/aa379570(v=vs.85).aspx
*/ */
WCHAR descriptor[] = TCHAR descriptor[] =
L"D:" // Discretionary ACL TEXT("D:") // Discretionary ACL
L"(D;OICI;GA;;;BG)" // Deny access to Built-in Guests TEXT("(D;OICI;GA;;;BG)") // Deny access to Built-in Guests
L"(D;OICI;GA;;;AN)" // Deny access to Anonymous Logon TEXT("(D;OICI;GA;;;AN)") // Deny access to Anonymous Logon
L"(A;OICI;GRGWGX;;;AU)" // Allow read/write/execute to Authenticated Users TEXT("(A;OICI;GRGWGX;;;AU)") // Allow read/write/execute to Authenticated Users
L"(A;OICI;GA;;;BA)"; // Allow full control to Administrators TEXT("(A;OICI;GA;;;BA)"); // Allow full control to Administrators
SECURITY_ATTRIBUTES securityAttributes; SECURITY_ATTRIBUTES securityAttributes;
PSECURITY_DESCRIPTOR securityDescriptor = PSECURITY_DESCRIPTOR securityDescriptor =
@ -246,7 +234,7 @@ bool AkVCam::MessageServerPrivate::startReceive(bool wait)
securityAttributes.bInheritHandle = TRUE; securityAttributes.bInheritHandle = TRUE;
// Create a read/write message type pipe. // Create a read/write message type pipe.
this->m_pipe = CreateNamedPipe(this->m_pipeName.c_str(), this->m_pipe = CreateNamedPipeA(this->m_pipeName.c_str(),
PIPE_ACCESS_DUPLEX PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED, | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_MESSAGE PIPE_TYPE_MESSAGE
@ -366,23 +354,17 @@ void AkVCam::MessageServerPrivate::messagesLoop()
void AkVCam::MessageServerPrivate::checkLoop() void AkVCam::MessageServerPrivate::checkLoop()
{ {
while (this->m_running) { while (this->m_running) {
auto result = WaitNamedPipe(this->m_pipeName.c_str(), NMPWAIT_NOWAIT); auto result = WaitNamedPipeA(this->m_pipeName.c_str(), NMPWAIT_NOWAIT);
if (result if (result
&& this->m_pipeState != AkVCam::MessageServer::PipeStateAvailable) { && this->m_pipeState != AkVCam::MessageServer::PipeStateAvailable) {
AkLogInfo() << "Pipe Available: " AkLogInfo() << "Pipe Available: " << this->m_pipeName << std::endl;
<< std::string(this->m_pipeName.begin(),
this->m_pipeName.end())
<< std::endl;
this->m_pipeState = AkVCam::MessageServer::PipeStateAvailable; this->m_pipeState = AkVCam::MessageServer::PipeStateAvailable;
AKVCAM_EMIT(this->self, PipeStateChanged, this->m_pipeState) AKVCAM_EMIT(this->self, PipeStateChanged, this->m_pipeState)
} else if (!result } else if (!result
&& this->m_pipeState != AkVCam::MessageServer::PipeStateGone && this->m_pipeState != AkVCam::MessageServer::PipeStateGone
&& GetLastError() != ERROR_SEM_TIMEOUT) { && GetLastError() != ERROR_SEM_TIMEOUT) {
AkLogInfo() << "Pipe Gone: " AkLogInfo() << "Pipe Gone: " << this->m_pipeName << std::endl;
<< std::string(this->m_pipeName.begin(),
this->m_pipeName.end())
<< std::endl;
this->m_pipeState = AkVCam::MessageServer::PipeStateGone; this->m_pipeState = AkVCam::MessageServer::PipeStateGone;
AKVCAM_EMIT(this->self, PipeStateChanged, this->m_pipeState) AKVCAM_EMIT(this->self, PipeStateChanged, this->m_pipeState)
} }

11
dshow/PlatformUtils/src/messageserver.h
View file

@ -66,9 +66,9 @@ namespace AkVCam
MessageServer(const MessageServer &other) = delete; MessageServer(const MessageServer &other) = delete;
~MessageServer(); ~MessageServer();
std::wstring pipeName() const; std::string pipeName() const;
std::wstring &pipeName(); std::string &pipeName();
void setPipeName(const std::wstring &pipeName); void setPipeName(const std::string &pipeName);
ServerMode mode() const; ServerMode mode() const;
ServerMode &mode(); ServerMode &mode();
void setMode(ServerMode mode); void setMode(ServerMode mode);
@ -87,10 +87,7 @@ namespace AkVCam
static BOOL sendMessage(const std::string &pipeName, static BOOL sendMessage(const std::string &pipeName,
Message *message, Message *message,
uint32_t timeout=MSERVER_TIMEOUT_MAX); uint32_t timeout=MSERVER_TIMEOUT_MAX);
static BOOL sendMessage(const std::wstring &pipeName, static BOOL sendMessage(const std::string &pipeName,
Message *message,
uint32_t timeout=MSERVER_TIMEOUT_MAX);
static BOOL sendMessage(const std::wstring &pipeName,
const Message &messageIn, const Message &messageIn,
Message *messageOut, Message *messageOut,
uint32_t timeout=MSERVER_TIMEOUT_MAX); uint32_t timeout=MSERVER_TIMEOUT_MAX);

15
dshow/PlatformUtils/src/mutex.cpp
View file

@ -27,24 +27,23 @@ namespace AkVCam
{ {
public: public:
HANDLE m_mutex; HANDLE m_mutex;
std::wstring m_name; std::string m_name;
}; };
} }
AkVCam::Mutex::Mutex(const std::wstring &name) AkVCam::Mutex::Mutex(const std::string &name)
{ {
this->d = new MutexPrivate(); this->d = new MutexPrivate();
this->d->m_mutex = CreateMutex(nullptr, this->d->m_mutex = CreateMutexA(nullptr,
FALSE, FALSE,
name.empty()? name.empty()? nullptr: name.c_str());
nullptr: name.c_str());
this->d->m_name = name; this->d->m_name = name;
} }
AkVCam::Mutex::Mutex(const Mutex &other) AkVCam::Mutex::Mutex(const Mutex &other)
{ {
this->d = new MutexPrivate(); this->d = new MutexPrivate();
this->d->m_mutex = CreateMutex(nullptr, this->d->m_mutex = CreateMutexA(nullptr,
FALSE, FALSE,
other.d->m_name.empty()? other.d->m_name.empty()?
nullptr: other.d->m_name.c_str()); nullptr: other.d->m_name.c_str());
@ -67,7 +66,7 @@ AkVCam::Mutex &AkVCam::Mutex::operator =(const Mutex &other)
if (this->d->m_mutex) if (this->d->m_mutex)
CloseHandle(this->d->m_mutex); CloseHandle(this->d->m_mutex);
this->d->m_mutex = CreateMutex(nullptr, this->d->m_mutex = CreateMutexA(nullptr,
FALSE, FALSE,
other.d->m_name.empty()? other.d->m_name.empty()?
nullptr: other.d->m_name.c_str()); nullptr: other.d->m_name.c_str());
@ -77,7 +76,7 @@ AkVCam::Mutex &AkVCam::Mutex::operator =(const Mutex &other)
return *this; return *this;
} }
std::wstring AkVCam::Mutex::name() const std::string AkVCam::Mutex::name() const
{ {
return this->d->m_name; return this->d->m_name;
} }

4
dshow/PlatformUtils/src/mutex.h
View file

@ -29,12 +29,12 @@ namespace AkVCam
class Mutex class Mutex
{ {
public: public:
Mutex(const std::wstring &name={}); Mutex(const std::string &name={});
Mutex(const Mutex &other); Mutex(const Mutex &other);
~Mutex(); ~Mutex();
Mutex &operator =(const Mutex &other); Mutex &operator =(const Mutex &other);
std::wstring name() const; std::string name() const;
void lock(); void lock();
bool tryLock(int timeout=0); bool tryLock(int timeout=0);
void unlock(); void unlock();

147
dshow/PlatformUtils/src/preferences.cpp
View file

@ -39,22 +39,14 @@ namespace AkVCam
void splitSubKey(const std::string &key, void splitSubKey(const std::string &key,
std::string &subKey, std::string &subKey,
std::string &value); std::string &value);
bool valueA(const std::string &key, bool readValue(const std::string &key,
DWORD dataTypeFlags, DWORD dataTypeFlags,
PVOID data, PVOID data,
LPDWORD dataSize); LPDWORD dataSize);
bool valueW(const std::string &key, void setValue(const std::string &key,
DWORD dataTypeFlags,
PVOID data,
LPDWORD dataSize);
void setValueA(const std::string &key,
DWORD dataType, DWORD dataType,
LPCSTR data, LPCSTR data,
DWORD dataSize); DWORD dataSize);
void setValueW(const std::string &key,
DWORD dataType,
LPCWSTR data,
DWORD dataSize);
} }
} }
@ -63,25 +55,14 @@ void AkVCam::Preferences::write(const std::string &key,
{ {
AkLogFunction(); AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << value << std::endl; AkLogInfo() << "Writing: " << key << " = " << value << std::endl;
setValueA(key, REG_SZ, value.c_str(), DWORD(value.size())); setValue(key, REG_SZ, value.c_str(), DWORD(value.size()));
}
void AkVCam::Preferences::write(const std::string &key,
const std::wstring &value)
{
AkLogFunction();
AkLogInfo() << "Writing: "
<< key
<< " = "
<< std::string(value.begin(), value.end()) << std::endl;
setValueW(key, REG_SZ, value.c_str(), DWORD(value.size()));
} }
void AkVCam::Preferences::write(const std::string &key, int value) void AkVCam::Preferences::write(const std::string &key, int value)
{ {
AkLogFunction(); AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << value << std::endl; AkLogInfo() << "Writing: " << key << " = " << value << std::endl;
setValueA(key, setValue(key,
REG_DWORD, REG_DWORD,
reinterpret_cast<const char *>(&value), reinterpret_cast<const char *>(&value),
DWORD(sizeof(int))); DWORD(sizeof(int)));
@ -92,7 +73,7 @@ void AkVCam::Preferences::write(const std::string &key, double value)
AkLogFunction(); AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << value << std::endl; AkLogInfo() << "Writing: " << key << " = " << value << std::endl;
auto val = std::to_string(value); auto val = std::to_string(value);
setValueA(key, setValue(key,
REG_SZ, REG_SZ,
val.c_str(), val.c_str(),
DWORD(val.size())); DWORD(val.size()));
@ -113,21 +94,7 @@ std::string AkVCam::Preferences::readString(const std::string &key,
memset(value, 0, MAX_PATH * sizeof(char)); memset(value, 0, MAX_PATH * sizeof(char));
DWORD valueSize = MAX_PATH; DWORD valueSize = MAX_PATH;
if (!valueA(key, RRF_RT_REG_SZ, &value, &valueSize)) if (!readValue(key, RRF_RT_REG_SZ, &value, &valueSize))
return defaultValue;
return {value};
}
std::wstring AkVCam::Preferences::readWString(const std::string &key,
const std::wstring &defaultValue)
{
AkLogFunction();
TCHAR value[MAX_PATH];
memset(value, 0, MAX_PATH * sizeof(TCHAR));
DWORD valueSize = MAX_PATH;
if (!valueW(key, RRF_RT_REG_SZ, &value, &valueSize))
return defaultValue; return defaultValue;
return {value}; return {value};
@ -139,7 +106,7 @@ int AkVCam::Preferences::readInt(const std::string &key, int defaultValue)
DWORD value = 0; DWORD value = 0;
DWORD valueSize = sizeof(DWORD); DWORD valueSize = sizeof(DWORD);
if (!valueA(key, RRF_RT_REG_DWORD, &value, &valueSize)) if (!readValue(key, RRF_RT_REG_DWORD, &value, &valueSize))
return defaultValue; return defaultValue;
return int(value); return int(value);
@ -174,7 +141,7 @@ std::vector<CLSID> AkVCam::Preferences::listRegisteredCameras(HINSTANCE hinstDLL
CoTaskMemFree(strIID); CoTaskMemFree(strIID);
HKEY key = nullptr; HKEY key = nullptr;
auto result = RegOpenKeyEx(HKEY_CLASSES_ROOT, auto result = RegOpenKeyExW(HKEY_CLASSES_ROOT,
ss.str().c_str(), ss.str().c_str(),
0, 0,
MAXIMUM_ALLOWED, MAXIMUM_ALLOWED,
@ -208,10 +175,10 @@ std::vector<CLSID> AkVCam::Preferences::listRegisteredCameras(HINSTANCE hinstDLL
FILETIME lastWrite; FILETIME lastWrite;
for (DWORD i = 0; i < subkeys; i++) { for (DWORD i = 0; i < subkeys; i++) {
TCHAR subKey[MAX_PATH]; WCHAR subKey[MAX_PATH];
memset(subKey, 0, MAX_PATH * sizeof(TCHAR)); memset(subKey, 0, MAX_PATH * sizeof(WCHAR));
DWORD subKeyLen = MAX_PATH; DWORD subKeyLen = MAX_PATH;
result = RegEnumKeyEx(key, result = RegEnumKeyExW(key,
i, i,
subKey, subKey,
&subKeyLen, &subKeyLen,
@ -229,7 +196,7 @@ std::vector<CLSID> AkVCam::Preferences::listRegisteredCameras(HINSTANCE hinstDLL
memset(path, 0, MAX_PATH * sizeof(WCHAR)); memset(path, 0, MAX_PATH * sizeof(WCHAR));
DWORD pathSize = MAX_PATH; DWORD pathSize = MAX_PATH;
if (RegGetValue(HKEY_CLASSES_ROOT, if (RegGetValueW(HKEY_CLASSES_ROOT,
ss.str().c_str(), ss.str().c_str(),
nullptr, nullptr,
RRF_RT_REG_SZ, RRF_RT_REG_SZ,
@ -238,9 +205,9 @@ std::vector<CLSID> AkVCam::Preferences::listRegisteredCameras(HINSTANCE hinstDLL
&pathSize) == ERROR_SUCCESS) { &pathSize) == ERROR_SUCCESS) {
WCHAR modulePath[MAX_PATH]; WCHAR modulePath[MAX_PATH];
memset(modulePath, 0, MAX_PATH * sizeof(WCHAR)); memset(modulePath, 0, MAX_PATH * sizeof(WCHAR));
GetModuleFileName(hinstDLL, modulePath, MAX_PATH); GetModuleFileNameW(hinstDLL, modulePath, MAX_PATH);
if (!lstrcmpi(path, modulePath)) { if (!lstrcmpiW(path, modulePath)) {
CLSID clsid; CLSID clsid;
memset(&clsid, 0, sizeof(CLSID)); memset(&clsid, 0, sizeof(CLSID));
CLSIDFromString(subKey, &clsid); CLSIDFromString(subKey, &clsid);
@ -320,7 +287,7 @@ void AkVCam::Preferences::move(const std::string &keyFrom,
} }
} }
std::string AkVCam::Preferences::addDevice(const std::wstring &description) std::string AkVCam::Preferences::addDevice(const std::string &description)
{ {
AkLogFunction(); AkLogFunction();
auto path = createDevicePath(); auto path = createDevicePath();
@ -333,14 +300,14 @@ std::string AkVCam::Preferences::addDevice(const std::wstring &description)
return path; return path;
} }
std::string AkVCam::Preferences::addCamera(const std::wstring &description, std::string AkVCam::Preferences::addCamera(const std::string &description,
const std::vector<VideoFormat> &formats) const std::vector<VideoFormat> &formats)
{ {
return addCamera("", description, formats); return addCamera("", description, formats);
} }
std::string AkVCam::Preferences::addCamera(const std::string &path, std::string AkVCam::Preferences::addCamera(const std::string &path,
const std::wstring &description, const std::string &description,
const std::vector<VideoFormat> &formats) const std::vector<VideoFormat> &formats)
{ {
AkLogFunction(); AkLogFunction();
@ -471,18 +438,18 @@ bool AkVCam::Preferences::cameraExists(const std::string &path)
return false; return false;
} }
std::wstring AkVCam::Preferences::cameraDescription(size_t cameraIndex) std::string AkVCam::Preferences::cameraDescription(size_t cameraIndex)
{ {
if (cameraIndex >= camerasCount()) if (cameraIndex >= camerasCount())
return {}; return {};
return readWString("Cameras\\" return readString("Cameras\\"
+ std::to_string(cameraIndex + 1) + std::to_string(cameraIndex + 1)
+ "\\description"); + "\\description");
} }
void AkVCam::Preferences::cameraSetDescription(size_t cameraIndex, void AkVCam::Preferences::cameraSetDescription(size_t cameraIndex,
const std::wstring &description) const std::string &description)
{ {
if (cameraIndex >= camerasCount()) if (cameraIndex >= camerasCount())
return; return;
@ -642,12 +609,12 @@ void AkVCam::Preferences::cameraSetControlValue(size_t cameraIndex,
value); value);
} }
std::wstring AkVCam::Preferences::picture() std::string AkVCam::Preferences::picture()
{ {
return readWString("picture"); return readString("picture");
} }
void AkVCam::Preferences::setPicture(const std::wstring &picture) void AkVCam::Preferences::setPicture(const std::string &picture)
{ {
write("picture", picture); write("picture", picture);
} }
@ -679,7 +646,7 @@ void AkVCam::Preferences::splitSubKey(const std::string &key,
} }
} }
bool AkVCam::Preferences::valueA(const std::string &key, bool AkVCam::Preferences::readValue(const std::string &key,
DWORD dataTypeFlags, DWORD dataTypeFlags,
PVOID data, PVOID data,
LPDWORD dataSize) LPDWORD dataSize)
@ -709,39 +676,7 @@ bool AkVCam::Preferences::valueA(const std::string &key,
return result == ERROR_SUCCESS; return result == ERROR_SUCCESS;
} }
bool AkVCam::Preferences::valueW(const std::string &key, void AkVCam::Preferences::setValue(const std::string &key,
DWORD dataTypeFlags,
PVOID data,
LPDWORD dataSize)
{
std::string subKey;
std::string val;
splitSubKey(key, subKey, val);
HKEY hkey = nullptr;
auto result = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
subKey.c_str(),
0,
KEY_READ | KEY_WOW64_64KEY,
&hkey);
if (result != ERROR_SUCCESS)
return false;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv;
auto wval = cv.from_bytes(val);
result = RegGetValueW(hkey,
nullptr,
wval.c_str(),
dataTypeFlags,
nullptr,
data,
dataSize);
RegCloseKey(hkey);
return result == ERROR_SUCCESS;
}
void AkVCam::Preferences::setValueA(const std::string &key,
DWORD dataType, DWORD dataType,
LPCSTR data, LPCSTR data,
DWORD dataSize) DWORD dataSize)
@ -770,35 +705,3 @@ void AkVCam::Preferences::setValueA(const std::string &key,
dataSize); dataSize);
RegCloseKey(hkey); RegCloseKey(hkey);
} }
void AkVCam::Preferences::setValueW(const std::string &key,
DWORD dataType,
LPCWSTR data,
DWORD dataSize)
{
std::string subKey;
std::string val;
splitSubKey(key, subKey, val);
HKEY hkey = nullptr;
LONG result = RegCreateKeyExA(HKEY_LOCAL_MACHINE,
subKey.c_str(),
0,
nullptr,
REG_OPTION_NON_VOLATILE,
KEY_WRITE | KEY_WOW64_64KEY,
nullptr,
&hkey,
nullptr);
if (result != ERROR_SUCCESS)
return;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv;
auto wval = cv.from_bytes(val);
RegSetValueW(hkey,
wval.c_str(),
dataType,
data,
dataSize);
RegCloseKey(hkey);
}

17
dshow/PlatformUtils/src/preferences.h
View file

@ -32,25 +32,22 @@ namespace AkVCam
namespace Preferences namespace Preferences
{ {
void write(const std::string &key, const std::string &value); void write(const std::string &key, const std::string &value);
void write(const std::string &key, const std::wstring &value);
void write(const std::string &key, int value); void write(const std::string &key, int value);
void write(const std::string &key, double value); void write(const std::string &key, double value);
void write(const std::string &key, std::vector<std::string> &value); void write(const std::string &key, std::vector<std::string> &value);
std::string readString(const std::string &key, std::string readString(const std::string &key,
const std::string &defaultValue={}); const std::string &defaultValue={});
std::wstring readWString(const std::string &key,
const std::wstring &defaultValue={});
int readInt(const std::string &key, int defaultValue=0); int readInt(const std::string &key, int defaultValue=0);
double readDouble(const std::string &key, double defaultValue=0.0); double readDouble(const std::string &key, double defaultValue=0.0);
bool readBool(const std::string &key, bool defaultValue=false); bool readBool(const std::string &key, bool defaultValue=false);
std::vector<CLSID> listRegisteredCameras(HINSTANCE hinstDLL); std::vector<CLSID> listRegisteredCameras(HINSTANCE hinstDLL);
void deleteKey(const std::string &key); void deleteKey(const std::string &key);
void move(const std::string &keyFrom, const std::string &keyTo); void move(const std::string &keyFrom, const std::string &keyTo);
std::string addDevice(const std::wstring &description); std::string addDevice(const std::string &description);
std::string addCamera(const std::wstring &description, std::string addCamera(const std::string &description,
const std::vector<VideoFormat> &formats); const std::vector<VideoFormat> &formats);
std::string addCamera(const std::string &path, std::string addCamera(const std::string &path,
const std::wstring &description, const std::string &description,
const std::vector<VideoFormat> &formats); const std::vector<VideoFormat> &formats);
void removeCamera(const std::string &path); void removeCamera(const std::string &path);
size_t camerasCount(); size_t camerasCount();
@ -58,9 +55,9 @@ namespace AkVCam
int cameraFromCLSID(const CLSID &clsid); int cameraFromCLSID(const CLSID &clsid);
int cameraFromPath(const std::string &path); int cameraFromPath(const std::string &path);
bool cameraExists(const std::string &path); bool cameraExists(const std::string &path);
std::wstring cameraDescription(size_t cameraIndex); std::string cameraDescription(size_t cameraIndex);
void cameraSetDescription(size_t cameraIndex, void cameraSetDescription(size_t cameraIndex,
const std::wstring &description); const std::string &description);
std::string cameraPath(size_t cameraIndex); std::string cameraPath(size_t cameraIndex);
size_t formatsCount(size_t cameraIndex); size_t formatsCount(size_t cameraIndex);
VideoFormat cameraFormat(size_t cameraIndex, size_t formatIndex); VideoFormat cameraFormat(size_t cameraIndex, size_t formatIndex);
@ -76,8 +73,8 @@ namespace AkVCam
void cameraSetControlValue(size_t cameraIndex, void cameraSetControlValue(size_t cameraIndex,
const std::string &key, const std::string &key,
int value); int value);
std::wstring picture(); std::string picture();
void setPicture(const std::wstring &picture); void setPicture(const std::string &picture);
int logLevel(); int logLevel();
void setLogLevel(int logLevel); void setLogLevel(int logLevel);
} }

15
dshow/PlatformUtils/src/sharedmemory.cpp
View file

@ -30,7 +30,7 @@ namespace AkVCam
{ {
public: public:
HANDLE m_sharedHandle; HANDLE m_sharedHandle;
std::wstring m_name; std::string m_name;
void *m_buffer; void *m_buffer;
size_t m_pageSize; size_t m_pageSize;
SharedMemory::OpenMode m_mode; SharedMemory::OpenMode m_mode;
@ -85,17 +85,17 @@ AkVCam::SharedMemory &AkVCam::SharedMemory::operator =(const SharedMemory &other
return *this; return *this;
} }
std::wstring AkVCam::SharedMemory::name() const std::string AkVCam::SharedMemory::name() const
{ {
return this->d->m_name; return this->d->m_name;
} }
std::wstring &AkVCam::SharedMemory::name() std::string &AkVCam::SharedMemory::name()
{ {
return this->d->m_name; return this->d->m_name;
} }
void AkVCam::SharedMemory::setName(const std::wstring &name) void AkVCam::SharedMemory::setName(const std::string &name)
{ {
this->d->m_name = name; this->d->m_name = name;
} }
@ -110,7 +110,7 @@ bool AkVCam::SharedMemory::open(size_t pageSize, OpenMode mode)
if (mode == OpenModeRead) { if (mode == OpenModeRead) {
this->d->m_sharedHandle = this->d->m_sharedHandle =
OpenFileMapping(FILE_MAP_ALL_ACCESS, OpenFileMappingA(FILE_MAP_ALL_ACCESS,
FALSE, FALSE,
this->d->m_name.c_str()); this->d->m_name.c_str());
} else { } else {
@ -118,7 +118,7 @@ bool AkVCam::SharedMemory::open(size_t pageSize, OpenMode mode)
return false; return false;
this->d->m_sharedHandle = this->d->m_sharedHandle =
CreateFileMapping(INVALID_HANDLE_VALUE, CreateFileMappingA(INVALID_HANDLE_VALUE,
nullptr, nullptr,
PAGE_READWRITE, PAGE_READWRITE,
0, 0,
@ -128,8 +128,7 @@ bool AkVCam::SharedMemory::open(size_t pageSize, OpenMode mode)
if (!this->d->m_sharedHandle) { if (!this->d->m_sharedHandle) {
AkLogError() << "Error opening shared memory (" AkLogError() << "Error opening shared memory ("
<< std::string(this->d->m_name.begin(), << this->d->m_name
this->d->m_name.end())
<< "): " << "): "
<< errorToString(GetLastError()) << errorToString(GetLastError())
<< " (" << GetLastError() << ")" << " (" << GetLastError() << ")"

6
dshow/PlatformUtils/src/sharedmemory.h
View file

@ -41,9 +41,9 @@ namespace AkVCam
~SharedMemory(); ~SharedMemory();
SharedMemory &operator =(const SharedMemory &other); SharedMemory &operator =(const SharedMemory &other);
std::wstring name() const; std::string name() const;
std::wstring &name(); std::string &name();
void setName(const std::wstring &name); void setName(const std::string &name);
bool open(size_t pageSize=0, OpenMode mode=OpenModeRead); bool open(size_t pageSize=0, OpenMode mode=OpenModeRead);
bool isOpen() const; bool isOpen() const;
size_t pageSize() const; size_t pageSize() const;

181
dshow/PlatformUtils/src/utils.cpp
View file

@ -29,6 +29,7 @@
#include "utils.h" #include "utils.h"
#include "VCamUtils/src/utils.h" #include "VCamUtils/src/utils.h"
#include "VCamUtils/src/image/videoformat.h" #include "VCamUtils/src/image/videoformat.h"
#include "VCamUtils/src/image/videoframe.h"
#define TIME_BASE 1.0e7 #define TIME_BASE 1.0e7
@ -85,16 +86,6 @@ bool operator <(const CLSID &a, const CLSID &b)
return AkVCam::stringFromIid(a) < AkVCam::stringFromIid(b); return AkVCam::stringFromIid(a) < AkVCam::stringFromIid(b);
} }
BOOL AkVCam::isWow64()
{
BOOL isWow64 = FALSE;
if (!IsWow64Process(GetCurrentProcess(), &isWow64))
return false;
return isWow64;
}
std::string AkVCam::tempPath() std::string AkVCam::tempPath()
{ {
CHAR tempPath[MAX_PATH]; CHAR tempPath[MAX_PATH];
@ -104,90 +95,35 @@ std::string AkVCam::tempPath()
return std::string(tempPath); return std::string(tempPath);
} }
std::wstring AkVCam::programFilesPath()
{
bool ok = false;
TCHAR programFiles[MAX_PATH];
DWORD programFilesSize = MAX_PATH * sizeof(TCHAR);
memset(programFiles, 0, programFilesSize);
HKEY hkey = nullptr;
auto result = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion",
0,
KEY_READ | KEY_WOW64_64KEY,
&hkey);
if (result == ERROR_SUCCESS) {
result = RegGetValue(hkey,
nullptr,
L"ProgramFilesDir",
RRF_RT_REG_SZ,
nullptr,
&programFiles,
&programFilesSize);
if (isWow64())
ok = true;
RegCloseKey(hkey);
}
if (!ok)
SHGetSpecialFolderPath(nullptr,
programFiles,
CSIDL_PROGRAM_FILES,
FALSE);
return std::wstring(programFiles);
}
std::wstring AkVCam::moduleFileNameW(HINSTANCE hinstDLL)
{
WCHAR fileName[MAX_PATH];
memset(fileName, 0, MAX_PATH * sizeof(WCHAR));
GetModuleFileName(hinstDLL, fileName, MAX_PATH);
return std::wstring(fileName);
}
std::string AkVCam::moduleFileName(HINSTANCE hinstDLL) std::string AkVCam::moduleFileName(HINSTANCE hinstDLL)
{ {
auto fileName = moduleFileNameW(hinstDLL); CHAR fileName[MAX_PATH];
memset(fileName, 0, MAX_PATH * sizeof(CHAR));
GetModuleFileNameA(hinstDLL, fileName, MAX_PATH);
return std::string(fileName.begin(), fileName.end()); return std::string(fileName);
} }
std::wstring AkVCam::errorToStringW(DWORD errorCode) std::string AkVCam::errorToString(DWORD errorCode)
{ {
WCHAR *errorStr = nullptr; CHAR *errorStr = nullptr;
auto size = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER auto size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS, | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, nullptr,
errorCode, errorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
reinterpret_cast<LPWSTR>(&errorStr), reinterpret_cast<LPSTR>(&errorStr),
0, 0,
nullptr); nullptr);
std::wstring error(errorStr, size); std::string error(errorStr, size);
LocalFree(errorStr); LocalFree(errorStr);
return error; return error;
} }
std::string AkVCam::errorToString(DWORD errorCode)
{
auto errorStr = errorToStringW(errorCode);
return std::string(errorStr.begin(), errorStr.end());
}
// Converts a human redable string to a CLSID using MD5 hash. // Converts a human redable string to a CLSID using MD5 hash.
CLSID AkVCam::createClsidFromStr(const std::string &str) CLSID AkVCam::createClsidFromStr(const std::string &str)
{
return createClsidFromStr(std::wstring(str.begin(), str.end()));
}
CLSID AkVCam::createClsidFromStr(const std::wstring &str)
{ {
HCRYPTPROV provider = 0; HCRYPTPROV provider = 0;
HCRYPTHASH hash = 0; HCRYPTHASH hash = 0;
@ -227,47 +163,35 @@ clsidFromStr_failed:
return clsid; return clsid;
} }
std::wstring AkVCam::createClsidWStrFromStr(const std::string &str) std::string AkVCam::createClsidStrFromStr(const std::string &str)
{
return createClsidWStrFromStr(std::wstring(str.begin(), str.end()));
}
std::wstring AkVCam::createClsidWStrFromStr(const std::wstring &str)
{ {
auto clsid = createClsidFromStr(str); auto clsid = createClsidFromStr(str);
OLECHAR *clsidWStr = nullptr; LPWSTR clsidWStr = nullptr;
if (StringFromCLSID(clsid, &clsidWStr) != S_OK) if (StringFromCLSID(clsid, &clsidWStr) != S_OK)
return std::wstring(); return {};
std::wstring wstr(clsidWStr); auto str_ = stringFromWSTR(clsidWStr);
CoTaskMemFree(clsidWStr); CoTaskMemFree(clsidWStr);
return wstr; return str_;
} }
std::string AkVCam::stringFromIid(const IID &iid) std::string AkVCam::stringFromIid(const IID &iid)
{ {
auto wstr = wstringFromIid(iid); LPWSTR strIID = nullptr;
return std::string(wstr.begin(), wstr.end());
}
std::wstring AkVCam::wstringFromIid(const IID &iid)
{
WCHAR *strIID = nullptr;
StringFromIID(iid, &strIID); StringFromIID(iid, &strIID);
std::wstring wstr(strIID); auto str = stringFromWSTR(strIID);
CoTaskMemFree(strIID); CoTaskMemFree(strIID);
return wstr; return str;
} }
std::string AkVCam::stringFromResult(HRESULT result) std::string AkVCam::stringFromResult(HRESULT result)
{ {
auto msg = std::wstring(_com_error(result).ErrorMessage()); auto msg = stringFromWSTR(_com_error(result).ErrorMessage());
return std::string(msg.begin(), msg.end()); return msg;
} }
std::string AkVCam::stringFromClsid(const CLSID &clsid) std::string AkVCam::stringFromClsid(const CLSID &clsid)
@ -332,17 +256,48 @@ std::string AkVCam::stringFromClsid(const CLSID &clsid)
return stringFromIid(clsid); return stringFromIid(clsid);
} }
wchar_t *AkVCam::wcharStrFromWStr(const std::wstring &wstr) std::string AkVCam::stringFromWSTR(LPCWSTR wstr)
{ {
if (wstr.size() < 1) auto len = WideCharToMultiByte(CP_ACP,
return nullptr; 0,
wstr,
-1,
nullptr,
0,
nullptr,
nullptr);
CHAR *cstr = new CHAR[len];
WideCharToMultiByte(CP_ACP,
0,
wstr,
-1,
cstr,
len,
nullptr,
nullptr);
std::string str(cstr);
delete [] cstr;
auto wcstrSize = wstr.size() * sizeof(wchar_t); return str;
auto wcstr = reinterpret_cast<wchar_t *>(CoTaskMemAlloc(wcstrSize + 1)); }
wcstr[wstr.size()] = 0;
memcpy(wcstr, wstr.data(), wcstrSize);
return wcstr; LPWSTR AkVCam::stringToWSTR(const std::string &str)
{
auto len = MultiByteToWideChar(CP_ACP,
0,
str.c_str(),
str.size(),
nullptr,
0);
auto wstr = reinterpret_cast<LPWSTR>(CoTaskMemAlloc(len * sizeof(WCHAR)));
MultiByteToWideChar(CP_ACP,
0,
str.c_str(),
str.size(),
wstr,
len);
return wstr;
} }
AkVCam::FourCC AkVCam::formatFromGuid(const GUID &guid) AkVCam::FourCC AkVCam::formatFromGuid(const GUID &guid)
@ -999,3 +954,21 @@ LSTATUS AkVCam::copyTree(HKEY src, LPCSTR subkey, HKEY dst, REGSAM samFlags)
return result; return result;
} }
AkVCam::VideoFrame AkVCam::loadPicture(const std::string &fileName)
{
AkLogFunction();
VideoFrame frame;
if (frame.load(fileName)) {
AkLogInfo() << "Picture loaded as BMP" << std::endl;
return frame;
}
AkLogDebug() << "Error loading picture: "
<< fileName
<< std::endl;
return frame;
}

14
dshow/PlatformUtils/src/utils.h
View file

@ -32,23 +32,18 @@
namespace AkVCam namespace AkVCam
{ {
class VideoFormat; class VideoFormat;
class VideoFrame;
BOOL isWow64();
std::string tempPath(); std::string tempPath();
std::wstring programFilesPath();
std::wstring moduleFileNameW(HINSTANCE hinstDLL);
std::string moduleFileName(HINSTANCE hinstDLL); std::string moduleFileName(HINSTANCE hinstDLL);
std::wstring errorToStringW(DWORD errorCode);
std::string errorToString(DWORD errorCode); std::string errorToString(DWORD errorCode);
CLSID createClsidFromStr(const std::string &str); CLSID createClsidFromStr(const std::string &str);
CLSID createClsidFromStr(const std::wstring &str); std::string createClsidStrFromStr(const std::string &str);
std::wstring createClsidWStrFromStr(const std::string &str);
std::wstring createClsidWStrFromStr(const std::wstring &str);
std::string stringFromIid(const IID &iid); std::string stringFromIid(const IID &iid);
std::wstring wstringFromIid(const IID &iid);
std::string stringFromResult(HRESULT result); std::string stringFromResult(HRESULT result);
std::string stringFromClsid(const CLSID &clsid); std::string stringFromClsid(const CLSID &clsid);
wchar_t *wcharStrFromWStr(const std::wstring &wstr); std::string stringFromWSTR(LPCWSTR wstr);
LPWSTR stringToWSTR(const std::string &str);
FourCC formatFromGuid(const GUID &guid); FourCC formatFromGuid(const GUID &guid);
const GUID &guidFromFormat(FourCC format); const GUID &guidFromFormat(FourCC format);
DWORD compressionFromFormat(FourCC format); DWORD compressionFromFormat(FourCC format);
@ -71,6 +66,7 @@ namespace AkVCam
std::string stringFromMediaSample(IMediaSample *mediaSample); std::string stringFromMediaSample(IMediaSample *mediaSample);
LSTATUS deleteTree(HKEY key, LPCSTR subkey, REGSAM samFlags); LSTATUS deleteTree(HKEY key, LPCSTR subkey, REGSAM samFlags);
LSTATUS copyTree(HKEY src, LPCSTR subkey, HKEY dst, REGSAM samFlags); LSTATUS copyTree(HKEY src, LPCSTR subkey, HKEY dst, REGSAM samFlags);
VideoFrame loadPicture(const std::string &fileName);
} }
#endif // PLATFORM_UTILS_H #endif // PLATFORM_UTILS_H

66
dshow/VCamIPC/src/ipcbridge.cpp
View file

@ -109,23 +109,21 @@ AkVCam::IpcBridge::~IpcBridge()
delete this->d; delete this->d;
} }
std::wstring AkVCam::IpcBridge::picture() const std::string AkVCam::IpcBridge::picture() const
{ {
return Preferences::picture(); return Preferences::picture();
} }
void AkVCam::IpcBridge::setPicture(const std::wstring &picture) void AkVCam::IpcBridge::setPicture(const std::string &picture)
{ {
Preferences::setPicture(picture); Preferences::setPicture(picture);
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> cv;
auto picture_ = cv.to_bytes(picture);
Message message; Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_PICTURE_UPDATED; message.messageId = AKVCAM_ASSISTANT_MSG_PICTURE_UPDATED;
message.dataSize = sizeof(MsgPictureUpdated); message.dataSize = sizeof(MsgPictureUpdated);
auto data = messageData<MsgPictureUpdated>(&message); auto data = messageData<MsgPictureUpdated>(&message);
memcpy(data->picture, memcpy(data->picture,
picture_.c_str(), picture.c_str(),
(std::min<size_t>)(picture_.size(), MAX_STRING)); (std::min<size_t>)(picture.size(), MAX_STRING));
this->d->m_mainServer.sendMessage(&message); this->d->m_mainServer.sendMessage(&message);
} }
@ -149,14 +147,13 @@ bool AkVCam::IpcBridge::registerPeer()
message.dataSize = sizeof(MsgRequestPort); message.dataSize = sizeof(MsgRequestPort);
auto requestData = messageData<MsgRequestPort>(&message); auto requestData = messageData<MsgRequestPort>(&message);
if (!MessageServer::sendMessage(L"\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME_L, if (!MessageServer::sendMessage("\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME,
&message)) &message))
return false; return false;
std::string portName(requestData->port); std::string portName(requestData->port);
auto pipeName = "\\\\.\\pipe\\" + portName; auto pipeName = "\\\\.\\pipe\\" + portName;
this->d->m_messageServer.setPipeName(std::wstring(pipeName.begin(), this->d->m_messageServer.setPipeName(pipeName);
pipeName.end()));
this->d->m_messageServer.setHandlers(this->d->m_messageHandlers); this->d->m_messageServer.setHandlers(this->d->m_messageHandlers);
AkLogInfo() << "Recommended port name: " << portName << std::endl; AkLogInfo() << "Recommended port name: " << portName << std::endl;
@ -179,7 +176,7 @@ bool AkVCam::IpcBridge::registerPeer()
AkLogInfo() << "Registering port name: " << portName << std::endl; AkLogInfo() << "Registering port name: " << portName << std::endl;
if (!MessageServer::sendMessage(L"\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME_L, if (!MessageServer::sendMessage("\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME,
&message)) { &message)) {
this->d->m_messageServer.stop(true); this->d->m_messageServer.stop(true);
@ -192,13 +189,8 @@ bool AkVCam::IpcBridge::registerPeer()
return false; return false;
} }
this->d->m_sharedMemory.setName(L"Local\\" this->d->m_sharedMemory.setName("Local\\" + portName + ".data");
+ std::wstring(portName.begin(), this->d->m_globalMutex = Mutex(portName + ".mutex");
portName.end())
+ L".data");
this->d->m_globalMutex = Mutex(std::wstring(portName.begin(),
portName.end())
+ L".mutex");
this->d->m_portName = portName; this->d->m_portName = portName;
AkLogInfo() << "Peer registered as " << portName << std::endl; AkLogInfo() << "Peer registered as " << portName << std::endl;
@ -220,7 +212,7 @@ void AkVCam::IpcBridge::unregisterPeer()
memcpy(data->port, memcpy(data->port,
this->d->m_portName.c_str(), this->d->m_portName.c_str(),
(std::min<size_t>)(this->d->m_portName.size(), MAX_STRING)); (std::min<size_t>)(this->d->m_portName.size(), MAX_STRING));
MessageServer::sendMessage(L"\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME_L, MessageServer::sendMessage("\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME,
&message); &message);
this->d->m_messageServer.stop(true); this->d->m_messageServer.stop(true);
this->d->m_portName.clear(); this->d->m_portName.clear();
@ -242,7 +234,7 @@ std::vector<std::string> AkVCam::IpcBridge::devices() const
return devices; return devices;
} }
std::wstring AkVCam::IpcBridge::description(const std::string &deviceId) const std::string AkVCam::IpcBridge::description(const std::string &deviceId) const
{ {
AkLogFunction(); AkLogFunction();
auto cameraIndex = Preferences::cameraFromPath(deviceId); auto cameraIndex = Preferences::cameraFromPath(deviceId);
@ -254,7 +246,7 @@ std::wstring AkVCam::IpcBridge::description(const std::string &deviceId) const
} }
void AkVCam::IpcBridge::setDescription(const std::string &deviceId, void AkVCam::IpcBridge::setDescription(const std::string &deviceId,
const std::wstring &description) const std::string &description)
{ {
AkLogFunction(); AkLogFunction();
auto cameraIndex = Preferences::cameraFromPath(deviceId); auto cameraIndex = Preferences::cameraFromPath(deviceId);
@ -456,8 +448,8 @@ std::vector<uint64_t> AkVCam::IpcBridge::clientsPids() const
auto currentPid = GetCurrentProcessId(); auto currentPid = GetCurrentProcessId();
for (size_t i = 0; i < nProcess; i++) { for (size_t i = 0; i < nProcess; i++) {
auto processHnd = OpenProcess(PROCESS_QUERY_INFORMATION | auto processHnd = OpenProcess(PROCESS_QUERY_INFORMATION
PROCESS_VM_READ, | PROCESS_VM_READ,
FALSE, FALSE,
process[i]); process[i]);
if (!processHnd) if (!processHnd)
@ -522,7 +514,7 @@ std::string AkVCam::IpcBridge::clientExe(uint64_t pid) const
return exe; return exe;
} }
std::string AkVCam::IpcBridge::addDevice(const std::wstring &description) std::string AkVCam::IpcBridge::addDevice(const std::string &description)
{ {
return Preferences::addDevice(description); return Preferences::addDevice(description);
} }
@ -602,10 +594,8 @@ bool AkVCam::IpcBridge::deviceStart(const std::string &deviceId,
return false; return false;
} }
std::wstring portName(this->d->m_portName.begin(), this->d->m_sharedMemory.setName("Local\\" + this->d->m_portName + ".data");
this->d->m_portName.end()); this->d->m_globalMutex = Mutex(this->d->m_portName + ".mutex");
this->d->m_sharedMemory.setName(L"Local\\" + portName + L".data");
this->d->m_globalMutex = Mutex(portName + L".mutex");
if (!this->d->m_sharedMemory.open(maxBufferSize, if (!this->d->m_sharedMemory.open(maxBufferSize,
SharedMemory::OpenModeWrite)) { SharedMemory::OpenModeWrite)) {
@ -755,7 +745,7 @@ bool AkVCam::IpcBridge::removeListener(const std::string &deviceId)
AkVCam::IpcBridgePrivate::IpcBridgePrivate(IpcBridge *self): AkVCam::IpcBridgePrivate::IpcBridgePrivate(IpcBridge *self):
self(self) self(self)
{ {
this->m_mainServer.setPipeName(L"\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME_L); this->m_mainServer.setPipeName("\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME);
this->m_mainServer.setMode(MessageServer::ServerModeSend); this->m_mainServer.setMode(MessageServer::ServerModeSend);
this->m_mainServer.connectPipeStateChanged(this, this->m_mainServer.connectPipeStateChanged(this,
&IpcBridgePrivate::pipeStateChanged); &IpcBridgePrivate::pipeStateChanged);
@ -811,18 +801,16 @@ std::string AkVCam::IpcBridgePrivate::dirname(const std::string &path)
void AkVCam::IpcBridgePrivate::updateDeviceSharedProperties() void AkVCam::IpcBridgePrivate::updateDeviceSharedProperties()
{ {
for (size_t i = 0; i < Preferences::camerasCount(); i++) { for (size_t i = 0; i < Preferences::camerasCount(); i++) {
auto cameraPath = Preferences::cameraPath(i); auto path = Preferences::cameraPath(i);
std::string deviceId(cameraPath.begin(), cameraPath.end());
Message message; Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_BROADCASTING; message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_BROADCASTING;
message.dataSize = sizeof(MsgBroadcasting); message.dataSize = sizeof(MsgBroadcasting);
auto data = messageData<MsgBroadcasting>(&message); auto data = messageData<MsgBroadcasting>(&message);
memcpy(data->device, memcpy(data->device,
deviceId.c_str(), path.c_str(),
(std::min<size_t>)(deviceId.size(), MAX_STRING)); (std::min<size_t>)(path.size(), MAX_STRING));
this->m_mainServer.sendMessage(&message); this->m_mainServer.sendMessage(&message);
this->updateDeviceSharedProperties(deviceId, this->updateDeviceSharedProperties(path,
std::string(data->broadcaster)); std::string(data->broadcaster));
} }
} }
@ -833,11 +821,9 @@ void AkVCam::IpcBridgePrivate::updateDeviceSharedProperties(const std::string &d
if (owner.empty()) { if (owner.empty()) {
this->m_devices[deviceId] = {SharedMemory(), Mutex()}; this->m_devices[deviceId] = {SharedMemory(), Mutex()};
} else { } else {
Mutex mutex(std::wstring(owner.begin(), owner.end()) + L".mutex"); Mutex mutex(owner + ".mutex");
SharedMemory sharedMemory; SharedMemory sharedMemory;
sharedMemory.setName(L"Local\\" sharedMemory.setName("Local\\" + owner + ".data");
+ std::wstring(owner.begin(), owner.end())
+ L".data");
if (sharedMemory.open()) if (sharedMemory.open())
this->m_devices[deviceId] = {sharedMemory, mutex}; this->m_devices[deviceId] = {sharedMemory, mutex};
@ -936,9 +922,7 @@ void AkVCam::IpcBridgePrivate::pictureUpdated(Message *message)
{ {
AkLogFunction(); AkLogFunction();
auto data = messageData<MsgPictureUpdated>(message); auto data = messageData<MsgPictureUpdated>(message);
AKVCAM_EMIT(this->self, AKVCAM_EMIT(this->self, PictureChanged, std::string(data->picture))
PictureChanged,
std::string(data->picture))
} }
void AkVCam::IpcBridgePrivate::deviceUpdate(Message *message) void AkVCam::IpcBridgePrivate::deviceUpdate(Message *message)

13
dshow/VirtualCamera/VirtualCamera.pro
View file

@ -121,17 +121,6 @@ RESOURCESPATH = $${DSHOW_PLUGIN_NAME}.plugin/share
DESTDIR = $${OUT_PWD}/../../$${INSTALLPATH} DESTDIR = $${OUT_PWD}/../../$${INSTALLPATH}
INSTALLS += \ INSTALLS += \
target \ target
resources
target.path = $${PREFIX}/$${INSTALLPATH} target.path = $${PREFIX}/$${INSTALLPATH}
resources.files = ../../share/TestFrame/TestFrame.bmp
resources.path = $${PREFIX}/$${RESOURCESPATH}
QMAKE_POST_LINK = \
$$sprintf($$QMAKE_MKDIR_CMD, \
$$shell_quote($$shell_path($${OUT_PWD}/../../$${RESOURCESPATH}))) \
$${CMD_SEP} \
$(COPY) $$shell_quote($$shell_path($${PWD}/../../share/TestFrame/TestFrame.bmp)) \
$$shell_quote($$shell_path($${OUT_PWD}/../../$${RESOURCESPATH}/TestFrame.bmp))

40
dshow/VirtualCamera/src/basefilter.cpp
View file

@ -58,14 +58,14 @@ namespace AkVCam
EnumPins *m_pins; EnumPins *m_pins;
VideoProcAmp *m_videoProcAmp; VideoProcAmp *m_videoProcAmp;
ReferenceClock *m_referenceClock; ReferenceClock *m_referenceClock;
std::wstring m_vendor; std::string m_vendor;
std::wstring m_filterName; std::string m_filterName;
IFilterGraph *m_filterGraph; IFilterGraph *m_filterGraph;
IpcBridge m_ipcBridge; IpcBridge m_ipcBridge;
BaseFilterPrivate(BaseFilter *self, BaseFilterPrivate(BaseFilter *self,
const std::wstring &filterName, const std::string &filterName,
const std::wstring &vendor); const std::string &vendor);
BaseFilterPrivate(const BaseFilterPrivate &other) = delete; BaseFilterPrivate(const BaseFilterPrivate &other) = delete;
~BaseFilterPrivate(); ~BaseFilterPrivate();
IEnumPins *pinsForDevice(const std::string &deviceId); IEnumPins *pinsForDevice(const std::string &deviceId);
@ -85,8 +85,8 @@ namespace AkVCam
} }
AkVCam::BaseFilter::BaseFilter(const GUID &clsid, AkVCam::BaseFilter::BaseFilter(const GUID &clsid,
const std::wstring &filterName, const std::string &filterName,
const std::wstring &vendor): const std::string &vendor):
MediaFilter(clsid, this) MediaFilter(clsid, this)
{ {
this->setParent(this, &IID_IBaseFilter); this->setParent(this, &IID_IBaseFilter);
@ -99,7 +99,7 @@ AkVCam::BaseFilter::~BaseFilter()
} }
void AkVCam::BaseFilter::addPin(const std::vector<AkVCam::VideoFormat> &formats, void AkVCam::BaseFilter::addPin(const std::vector<AkVCam::VideoFormat> &formats,
const std::wstring &pinName, const std::string &pinName,
bool changed) bool changed)
{ {
AkLogFunction(); AkLogFunction();
@ -123,15 +123,12 @@ AkVCam::BaseFilter *AkVCam::BaseFilter::create(const GUID &clsid)
return nullptr; return nullptr;
auto description = Preferences::cameraDescription(size_t(camera)); auto description = Preferences::cameraDescription(size_t(camera));
AkLogInfo() << "Description: " AkLogInfo() << "Description: " << description << std::endl;
<< std::string(description.begin(),
description.end())
<< std::endl;
auto baseFilter = new BaseFilter(clsid, auto baseFilter = new BaseFilter(clsid,
description, description,
DSHOW_PLUGIN_VENDOR_L); DSHOW_PLUGIN_VENDOR);
auto formats = Preferences::cameraFormats(size_t(camera)); auto formats = Preferences::cameraFormats(size_t(camera));
baseFilter->addPin(formats, L"Video", false); baseFilter->addPin(formats, "Video", false);
return baseFilter; return baseFilter;
} }
@ -282,10 +279,12 @@ HRESULT AkVCam::BaseFilter::QueryFilterInfo(FILTER_INFO *pInfo)
memset(pInfo->achName, 0, MAX_FILTER_NAME * sizeof(WCHAR)); memset(pInfo->achName, 0, MAX_FILTER_NAME * sizeof(WCHAR));
if (this->d->m_filterName.size() > 0) { if (this->d->m_filterName.size() > 0) {
auto filterName = stringToWSTR(this->d->m_filterName);
memcpy(pInfo->achName, memcpy(pInfo->achName,
this->d->m_filterName.c_str(), filterName,
std::max<size_t>(this->d->m_filterName.size() * sizeof(WCHAR), std::max<size_t>(this->d->m_filterName.size() * sizeof(WCHAR),
MAX_FILTER_NAME)); MAX_FILTER_NAME));
CoTaskMemFree(filterName);
} }
pInfo->pGraph = this->d->m_filterGraph; pInfo->pGraph = this->d->m_filterGraph;
@ -301,13 +300,10 @@ HRESULT AkVCam::BaseFilter::JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName)
AkLogFunction(); AkLogFunction();
this->d->m_filterGraph = pGraph; this->d->m_filterGraph = pGraph;
this->d->m_filterName = std::wstring(pName? pName: L""); this->d->m_filterName = pName? stringFromWSTR(pName): "";
AkLogInfo() << "Filter graph: " << this->d->m_filterGraph << std::endl; AkLogInfo() << "Filter graph: " << this->d->m_filterGraph << std::endl;
AkLogInfo() << "Name: " AkLogInfo() << "Name: " << this->d->m_filterName << std::endl;
<< std::string(this->d->m_filterName.begin(),
this->d->m_filterName.end())
<< std::endl;
return S_OK; return S_OK;
} }
@ -322,7 +318,7 @@ HRESULT AkVCam::BaseFilter::QueryVendorInfo(LPWSTR *pVendorInfo)
if (!pVendorInfo) if (!pVendorInfo)
return E_POINTER; return E_POINTER;
*pVendorInfo = wcharStrFromWStr(this->d->m_vendor); *pVendorInfo = stringToWSTR(this->d->m_vendor);
return S_OK; return S_OK;
} }
@ -345,8 +341,8 @@ void AkVCam::BaseFilter::stateChanged(FILTER_STATE state)
} }
AkVCam::BaseFilterPrivate::BaseFilterPrivate(AkVCam::BaseFilter *self, AkVCam::BaseFilterPrivate::BaseFilterPrivate(AkVCam::BaseFilter *self,
const std::wstring &filterName, const std::string &filterName,
const std::wstring &vendor): const std::string &vendor):
self(self), self(self),
m_pins(new AkVCam::EnumPins), m_pins(new AkVCam::EnumPins),
m_videoProcAmp(new VideoProcAmp), m_videoProcAmp(new VideoProcAmp),

6
dshow/VirtualCamera/src/basefilter.h
View file

@ -36,12 +36,12 @@ namespace AkVCam
{ {
public: public:
BaseFilter(const GUID &clsid, BaseFilter(const GUID &clsid,
const std::wstring &filterName={}, const std::string &filterName={},
const std::wstring &vendor={}); const std::string &vendor={});
virtual ~BaseFilter(); virtual ~BaseFilter();
void addPin(const std::vector<VideoFormat> &formats={}, void addPin(const std::vector<VideoFormat> &formats={},
const std::wstring &pinName={}, const std::string &pinName={},
bool changed=true); bool changed=true);
void removePin(IPin *pin, bool changed=true); void removePin(IPin *pin, bool changed=true);
static BaseFilter *create(const GUID &clsid); static BaseFilter *create(const GUID &clsid);

33
dshow/VirtualCamera/src/pin.cpp
View file

@ -36,6 +36,7 @@
#include "qualitycontrol.h" #include "qualitycontrol.h"
#include "referenceclock.h" #include "referenceclock.h"
#include "videoprocamp.h" #include "videoprocamp.h"
#include "PlatformUtils/src/preferences.h"
#include "PlatformUtils/src/utils.h" #include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/image/videoformat.h" #include "VCamUtils/src/image/videoformat.h"
#include "VCamUtils/src/image/videoframe.h" #include "VCamUtils/src/image/videoframe.h"
@ -49,8 +50,8 @@ namespace AkVCam
Pin *self; Pin *self;
BaseFilter *m_baseFilter; BaseFilter *m_baseFilter;
VideoProcAmp *m_videoProcAmp; VideoProcAmp *m_videoProcAmp;
std::wstring m_pinName; std::string m_pinName;
std::wstring m_pinId; std::string m_pinId;
EnumMediaTypes *m_mediaTypes; EnumMediaTypes *m_mediaTypes;
IPin *m_connectedTo; IPin *m_connectedTo;
IMemInputPin *m_memInputPin; IMemInputPin *m_memInputPin;
@ -96,7 +97,7 @@ namespace AkVCam
AkVCam::Pin::Pin(BaseFilter *baseFilter, AkVCam::Pin::Pin(BaseFilter *baseFilter,
const std::vector<VideoFormat> &formats, const std::vector<VideoFormat> &formats,
const std::wstring &pinName): const std::string &pinName):
StreamConfig(this) StreamConfig(this)
{ {
this->setParent(this, &IID_IPin); this->setParent(this, &IID_IPin);
@ -105,9 +106,9 @@ AkVCam::Pin::Pin(BaseFilter *baseFilter,
this->d->self = this; this->d->self = this;
this->d->m_baseFilter = baseFilter; this->d->m_baseFilter = baseFilter;
this->d->m_pinName = pinName; this->d->m_pinName = pinName;
std::wstringstream wss; std::stringstream ss;
wss << L"pin(" << this << L")"; ss << "pin(" << this << ")";
this->d->m_pinId = wss.str(); this->d->m_pinId = ss.str();
this->d->m_mediaTypes = new AkVCam::EnumMediaTypes(formats); this->d->m_mediaTypes = new AkVCam::EnumMediaTypes(formats);
this->d->m_mediaTypes->AddRef(); this->d->m_mediaTypes->AddRef();
this->d->m_connectedTo = nullptr; this->d->m_connectedTo = nullptr;
@ -124,9 +125,10 @@ AkVCam::Pin::Pin(BaseFilter *baseFilter,
this->d->m_adviseCookie = 0; this->d->m_adviseCookie = 0;
this->d->m_sendFrameEvent = nullptr; this->d->m_sendFrameEvent = nullptr;
this->d->m_running = false; this->d->m_running = false;
auto bmp = programFilesPath() auto picture = Preferences::picture();
+ L"\\" DSHOW_PLUGIN_NAME_L L".plugin\\share\\TestFrame.bmp";
this->d->m_testFrame.load(std::string(bmp.begin(), bmp.end())); if (!picture.empty())
this->d->m_testFrame = loadPicture(picture);
baseFilter->QueryInterface(IID_IAMVideoProcAmp, baseFilter->QueryInterface(IID_IAMVideoProcAmp,
reinterpret_cast<void **>(&this->d->m_videoProcAmp)); reinterpret_cast<void **>(&this->d->m_videoProcAmp));
@ -671,11 +673,14 @@ HRESULT AkVCam::Pin::QueryPinInfo(PIN_INFO *pInfo)
pInfo->dir = PINDIR_OUTPUT; pInfo->dir = PINDIR_OUTPUT;
memset(pInfo->achName, 0, MAX_PIN_NAME * sizeof(WCHAR)); memset(pInfo->achName, 0, MAX_PIN_NAME * sizeof(WCHAR));
if (!this->d->m_pinName.empty()) if (!this->d->m_pinName.empty()) {
auto pinName = stringToWSTR(this->d->m_pinName);
memcpy(pInfo->achName, memcpy(pInfo->achName,
this->d->m_pinName.c_str(), pinName,
(std::min<size_t>)(this->d->m_pinName.size() * sizeof(WCHAR), (std::min<size_t>)(this->d->m_pinName.size() * sizeof(WCHAR),
MAX_PIN_NAME)); MAX_PIN_NAME));
CoTaskMemFree(pinName);
}
return S_OK; return S_OK;
} }
@ -706,9 +711,9 @@ HRESULT AkVCam::Pin::QueryId(LPWSTR *Id)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
memset(*Id, 0, wstrSize); memset(*Id, 0, wstrSize);
memcpy(*Id, auto pinId = stringToWSTR(this->d->m_pinId);
this->d->m_pinId.c_str(), memcpy(*Id, pinId, this->d->m_pinId.size() * sizeof(WCHAR));
this->d->m_pinId.size() * sizeof(WCHAR)); CoTaskMemFree(pinId);
return S_OK; return S_OK;
} }

2
dshow/VirtualCamera/src/pin.h
View file

@ -41,7 +41,7 @@ namespace AkVCam
public: public:
Pin(BaseFilter *baseFilter=nullptr, Pin(BaseFilter *baseFilter=nullptr,
const std::vector<AkVCam::VideoFormat> &formats={}, const std::vector<AkVCam::VideoFormat> &formats={},
const std::wstring &pinName={}); const std::string &pinName={});
virtual ~Pin(); virtual ~Pin();
BaseFilter *baseFilter() const; BaseFilter *baseFilter() const;

9
dshow/VirtualCamera/src/plugin.cpp
View file

@ -118,13 +118,8 @@ STDAPI DllRegisterServer()
auto clsid = AkVCam::createClsidFromStr(path); auto clsid = AkVCam::createClsidFromStr(path);
AkLogInfo() << "Creating Camera" << std::endl; AkLogInfo() << "Creating Camera" << std::endl;
AkLogInfo() << "\tDescription: " AkLogInfo() << "\tDescription: " << description << std::endl;
<< std::string(description.begin(), AkLogInfo() << "\tPath: " << path << std::endl;
description.end())
<< std::endl;
AkLogInfo() << "\tPath: "
<< std::string(path.begin(), path.end())
<< std::endl;
AkLogInfo() << "\tCLSID: " << AkVCam::stringFromIid(clsid) << std::endl; AkLogInfo() << "\tCLSID: " << AkVCam::stringFromIid(clsid) << std::endl;
ok &= pluginInterface()->createDevice(path, description); ok &= pluginInterface()->createDevice(path, description);

74
dshow/VirtualCamera/src/plugininterface.cpp
View file

@ -56,32 +56,32 @@ HINSTANCE &AkVCam::PluginInterface::pluginHinstance()
} }
bool AkVCam::PluginInterface::registerServer(const std::string &deviceId, bool AkVCam::PluginInterface::registerServer(const std::string &deviceId,
const std::wstring &description) const const std::string &description) const
{ {
AkLogFunction(); AkLogFunction();
// Define the layout in registry of the filter. // Define the layout in registry of the filter.
auto clsid = createClsidWStrFromStr(deviceId); auto clsid = createClsidStrFromStr(deviceId);
auto fileName = AkVCam::moduleFileNameW(this->d->m_pluginHinstance); auto fileName = moduleFileName(this->d->m_pluginHinstance);
std::wstring threadingModel = L"Both"; std::string threadingModel = "Both";
AkLogInfo() << "CLSID: " << std::string(clsid.begin(), clsid.end()) << std::endl; AkLogInfo() << "CLSID: " << clsid << std::endl;
AkLogInfo() << "Description: " << std::string(description.begin(), description.end()) << std::endl; AkLogInfo() << "Description: " << description << std::endl;
AkLogInfo() << "Filename: " << std::string(fileName.begin(), fileName.end()) << std::endl; AkLogInfo() << "Filename: " << fileName << std::endl;
auto subkey = L"CLSID\\" + clsid; auto subkey = "CLSID\\" + clsid;
HKEY keyCLSID = nullptr; HKEY keyCLSID = nullptr;
HKEY keyServerType = nullptr; HKEY keyServerType = nullptr;
LONG result = RegCreateKey(HKEY_CLASSES_ROOT, subkey.c_str(), &keyCLSID); LONG result = RegCreateKeyA(HKEY_CLASSES_ROOT, subkey.c_str(), &keyCLSID);
bool ok = false; bool ok = false;
if (result != ERROR_SUCCESS) if (result != ERROR_SUCCESS)
goto registerServer_failed; goto registerServer_failed;
result = result =
RegSetValue(keyCLSID, RegSetValueA(keyCLSID,
nullptr, nullptr,
REG_SZ, REG_SZ,
description.c_str(), description.c_str(),
@ -90,13 +90,13 @@ bool AkVCam::PluginInterface::registerServer(const std::string &deviceId,
if (result != ERROR_SUCCESS) if (result != ERROR_SUCCESS)
goto registerServer_failed; goto registerServer_failed;
result = RegCreateKey(keyCLSID, L"InprocServer32", &keyServerType); result = RegCreateKey(keyCLSID, TEXT("InprocServer32"), &keyServerType);
if (result != ERROR_SUCCESS) if (result != ERROR_SUCCESS)
goto registerServer_failed; goto registerServer_failed;
result = result =
RegSetValue(keyServerType, RegSetValueA(keyServerType,
nullptr, nullptr,
REG_SZ, REG_SZ,
fileName.c_str(), fileName.c_str(),
@ -106,8 +106,8 @@ bool AkVCam::PluginInterface::registerServer(const std::string &deviceId,
goto registerServer_failed; goto registerServer_failed;
result = result =
RegSetValueEx(keyServerType, RegSetValueExA(keyServerType,
L"ThreadingModel", "ThreadingModel",
0L, 0L,
REG_SZ, REG_SZ,
reinterpret_cast<const BYTE *>(threadingModel.c_str()), reinterpret_cast<const BYTE *>(threadingModel.c_str()),
@ -134,13 +134,6 @@ void AkVCam::PluginInterface::unregisterServer(const std::string &deviceId) cons
this->unregisterServer(createClsidFromStr(deviceId)); this->unregisterServer(createClsidFromStr(deviceId));
} }
void AkVCam::PluginInterface::unregisterServer(const std::wstring &deviceId) const
{
AkLogFunction();
this->unregisterServer(createClsidFromStr(deviceId));
}
void AkVCam::PluginInterface::unregisterServer(const CLSID &clsid) const void AkVCam::PluginInterface::unregisterServer(const CLSID &clsid) const
{ {
AkLogFunction(); AkLogFunction();
@ -152,7 +145,7 @@ void AkVCam::PluginInterface::unregisterServer(const CLSID &clsid) const
} }
bool AkVCam::PluginInterface::registerFilter(const std::string &deviceId, bool AkVCam::PluginInterface::registerFilter(const std::string &deviceId,
const std::wstring &description) const const std::string &description) const
{ {
AkLogFunction(); AkLogFunction();
@ -182,6 +175,7 @@ bool AkVCam::PluginInterface::registerFilter(const std::string &deviceId,
auto result = CoInitialize(nullptr); auto result = CoInitialize(nullptr);
bool ok = false; bool ok = false;
LPWSTR wdescription = nullptr;
if (FAILED(result)) if (FAILED(result))
goto registerFilter_failed; goto registerFilter_failed;
@ -195,13 +189,14 @@ bool AkVCam::PluginInterface::registerFilter(const std::string &deviceId,
if (FAILED(result)) if (FAILED(result))
goto registerFilter_failed; goto registerFilter_failed;
wdescription = stringToWSTR(description);
result = filterMapper->RegisterFilter(clsid, result = filterMapper->RegisterFilter(clsid,
description.c_str(), wdescription,
&pMoniker, &pMoniker,
&CLSID_VideoInputDeviceCategory, &CLSID_VideoInputDeviceCategory,
nullptr, nullptr,
&regFilter); &regFilter);
CoTaskMemFree(wdescription);
ok = true; ok = true;
registerFilter_failed: registerFilter_failed:
@ -223,13 +218,6 @@ void AkVCam::PluginInterface::unregisterFilter(const std::string &deviceId) cons
this->unregisterFilter(AkVCam::createClsidFromStr(deviceId)); this->unregisterFilter(AkVCam::createClsidFromStr(deviceId));
} }
void AkVCam::PluginInterface::unregisterFilter(const std::wstring &deviceId) const
{
AkLogFunction();
this->unregisterFilter(AkVCam::createClsidFromStr(deviceId));
}
void AkVCam::PluginInterface::unregisterFilter(const CLSID &clsid) const void AkVCam::PluginInterface::unregisterFilter(const CLSID &clsid) const
{ {
AkLogFunction(); AkLogFunction();
@ -265,16 +253,16 @@ bool AkVCam::PluginInterface::setDevicePath(const std::string &deviceId) const
{ {
AkLogFunction(); AkLogFunction();
std::wstring subKey = std::string subKey =
L"CLSID\\" "CLSID\\"
+ wstringFromIid(CLSID_VideoInputDeviceCategory) + stringFromIid(CLSID_VideoInputDeviceCategory)
+ L"\\Instance\\" + "\\Instance\\"
+ createClsidWStrFromStr(deviceId); + createClsidStrFromStr(deviceId);
AkLogInfo() << "Key: HKEY_CLASSES_ROOT" << std::endl; AkLogInfo() << "Key: HKEY_CLASSES_ROOT" << std::endl;
AkLogInfo() << "SubKey: " << std::string(subKey.begin(), subKey.end()) << std::endl; AkLogInfo() << "SubKey: " << subKey << std::endl;
HKEY hKey = nullptr; HKEY hKey = nullptr;
auto result = RegOpenKeyEx(HKEY_CLASSES_ROOT, auto result = RegOpenKeyExA(HKEY_CLASSES_ROOT,
subKey.c_str(), subKey.c_str(),
0, 0,
KEY_ALL_ACCESS, KEY_ALL_ACCESS,
@ -306,7 +294,7 @@ setDevicePath_failed:
} }
bool AkVCam::PluginInterface::createDevice(const std::string &deviceId, bool AkVCam::PluginInterface::createDevice(const std::string &deviceId,
const std::wstring &description) const std::string &description)
{ {
AkLogFunction(); AkLogFunction();
@ -335,14 +323,6 @@ void AkVCam::PluginInterface::destroyDevice(const std::string &deviceId)
this->unregisterServer(deviceId); this->unregisterServer(deviceId);
} }
void AkVCam::PluginInterface::destroyDevice(const std::wstring &deviceId)
{
AkLogFunction();
this->unregisterFilter(deviceId);
this->unregisterServer(deviceId);
}
void AkVCam::PluginInterface::destroyDevice(const CLSID &clsid) void AkVCam::PluginInterface::destroyDevice(const CLSID &clsid)
{ {
AkLogFunction(); AkLogFunction();

9
dshow/VirtualCamera/src/plugininterface.h
View file

@ -37,20 +37,17 @@ namespace AkVCam
HINSTANCE pluginHinstance() const; HINSTANCE pluginHinstance() const;
HINSTANCE &pluginHinstance(); HINSTANCE &pluginHinstance();
bool registerServer(const std::string &deviceId, bool registerServer(const std::string &deviceId,
const std::wstring &description) const; const std::string &description) const;
void unregisterServer(const std::string &deviceId) const; void unregisterServer(const std::string &deviceId) const;
void unregisterServer(const std::wstring &deviceId) const;
void unregisterServer(const CLSID &clsid) const; void unregisterServer(const CLSID &clsid) const;
bool registerFilter(const std::string &deviceId, bool registerFilter(const std::string &deviceId,
const std::wstring &description) const; const std::string &description) const;
void unregisterFilter(const std::string &deviceId) const; void unregisterFilter(const std::string &deviceId) const;
void unregisterFilter(const std::wstring &deviceId) const;
void unregisterFilter(const CLSID &clsid) const; void unregisterFilter(const CLSID &clsid) const;
bool setDevicePath(const std::string &deviceId) const; bool setDevicePath(const std::string &deviceId) const;
bool createDevice(const std::string &deviceId, bool createDevice(const std::string &deviceId,
const std::wstring &description); const std::string &description);
void destroyDevice(const std::string &deviceId); void destroyDevice(const std::string &deviceId);
void destroyDevice(const std::wstring &deviceId);
void destroyDevice(const CLSID &clsid); void destroyDevice(const CLSID &clsid);
private: private:

9
dshow/dshow.pri
View file

@ -33,19 +33,12 @@ isEmpty(DSHOW_PLUGIN_VENDOR):
DEFINES += \ DEFINES += \
DSHOW_PLUGIN_NAME=\"\\\"$$DSHOW_PLUGIN_NAME\\\"\" \ DSHOW_PLUGIN_NAME=\"\\\"$$DSHOW_PLUGIN_NAME\\\"\" \
DSHOW_PLUGIN_NAME_L=\"L\\\"$$DSHOW_PLUGIN_NAME\\\"\" \
DSHOW_PLUGIN_ASSISTANT_NAME=\"\\\"$$DSHOW_PLUGIN_ASSISTANT_NAME\\\"\" \ DSHOW_PLUGIN_ASSISTANT_NAME=\"\\\"$$DSHOW_PLUGIN_ASSISTANT_NAME\\\"\" \
DSHOW_PLUGIN_ASSISTANT_NAME_L=\"L\\\"$$DSHOW_PLUGIN_ASSISTANT_NAME\\\"\" \
DSHOW_PLUGIN_ASSISTANT_DESCRIPTION=\"\\\"$$DSHOW_PLUGIN_ASSISTANT_DESCRIPTION\\\"\" \ DSHOW_PLUGIN_ASSISTANT_DESCRIPTION=\"\\\"$$DSHOW_PLUGIN_ASSISTANT_DESCRIPTION\\\"\" \
DSHOW_PLUGIN_ASSISTANT_DESCRIPTION_L=\"L\\\"$$DSHOW_PLUGIN_ASSISTANT_DESCRIPTION\\\"\" \
DSHOW_PLUGIN_DESCRIPTION=\"\\\"$$DSHOW_PLUGIN_DESCRIPTION\\\"\" \ DSHOW_PLUGIN_DESCRIPTION=\"\\\"$$DSHOW_PLUGIN_DESCRIPTION\\\"\" \
DSHOW_PLUGIN_DESCRIPTION_L=\"L\\\"$$DSHOW_PLUGIN_DESCRIPTION\\\"\" \
DSHOW_PLUGIN_DESCRIPTION_EXT=\"\\\"$$DSHOW_PLUGIN_DESCRIPTION_EXT\\\"\" \ DSHOW_PLUGIN_DESCRIPTION_EXT=\"\\\"$$DSHOW_PLUGIN_DESCRIPTION_EXT\\\"\" \
DSHOW_PLUGIN_DESCRIPTION_EXT_L=\"L\\\"$$DSHOW_PLUGIN_DESCRIPTION_EXT\\\"\" \
DSHOW_PLUGIN_DEVICE_PREFIX=\"\\\"$$DSHOW_PLUGIN_DEVICE_PREFIX\\\"\" \ DSHOW_PLUGIN_DEVICE_PREFIX=\"\\\"$$DSHOW_PLUGIN_DEVICE_PREFIX\\\"\" \
DSHOW_PLUGIN_DEVICE_PREFIX_L=\"L\\\"$$DSHOW_PLUGIN_DEVICE_PREFIX\\\"\" \ DSHOW_PLUGIN_VENDOR=\"\\\"$$DSHOW_PLUGIN_VENDOR\\\"\"
DSHOW_PLUGIN_VENDOR=\"\\\"$$DSHOW_PLUGIN_VENDOR\\\"\" \
DSHOW_PLUGIN_VENDOR_L=\"L\\\"$$DSHOW_PLUGIN_VENDOR\\\"\"
defineReplace(normalizedArch) { defineReplace(normalizedArch) {
arch = $$replace($$1, i386, x86) arch = $$replace($$1, i386, x86)

2
ports/deploy/deploy_mac.py
View file

@ -53,7 +53,7 @@ class Deploy(deploy_base.DeployBase, tools.qt5.DeployToolsQt):
self.dependencies = [] self.dependencies = []
self.installerConfig = os.path.join(self.installDir, 'installer/config') self.installerConfig = os.path.join(self.installDir, 'installer/config')
self.installerPackages = os.path.join(self.installDir, 'installer/packages') self.installerPackages = os.path.join(self.installDir, 'installer/packages')
self.appIcon = os.path.join(self.rootDir, 'share/TestFrame/webcamoid.png') self.appIcon = os.path.join(self.rootDir, 'share/icons/webcamoid.png')
self.licenseFile = os.path.join(self.rootDir, 'COPYING') self.licenseFile = os.path.join(self.rootDir, 'COPYING')
self.installerTargetDir = '@ApplicationsDir@/' + self.programName self.installerTargetDir = '@ApplicationsDir@/' + self.programName
self.installerScript = os.path.join(self.rootDir, 'ports/deploy/installscript.mac.qs') self.installerScript = os.path.join(self.rootDir, 'ports/deploy/installscript.mac.qs')

2
ports/deploy/deploy_posix_windows.py
View file

@ -51,7 +51,7 @@ class Deploy(deploy_base.DeployBase, tools.qt5.DeployToolsQt):
self.dependencies = [] self.dependencies = []
self.installerConfig = os.path.join(self.installDir, 'installer/config') self.installerConfig = os.path.join(self.installDir, 'installer/config')
self.installerPackages = os.path.join(self.installDir, 'installer/packages') self.installerPackages = os.path.join(self.installDir, 'installer/packages')
self.appIcon = os.path.join(self.rootDir, 'share/TestFrame/webcamoid.png') self.appIcon = os.path.join(self.rootDir, 'share/icons/webcamoid.png')
self.licenseFile = os.path.join(self.rootDir, 'COPYING') self.licenseFile = os.path.join(self.rootDir, 'COPYING')
self.installerScript = os.path.join(self.rootDir, 'ports/deploy/installscript.windows.qs') self.installerScript = os.path.join(self.rootDir, 'ports/deploy/installscript.windows.qs')
self.changeLog = os.path.join(self.rootDir, 'ChangeLog') self.changeLog = os.path.join(self.rootDir, 'ChangeLog')

2
ports/deploy/deploy_windows.py
View file

@ -51,7 +51,7 @@ class Deploy(deploy_base.DeployBase, tools.qt5.DeployToolsQt):
self.dependencies = [] self.dependencies = []
self.installerConfig = os.path.join(self.installDir, 'installer/config') self.installerConfig = os.path.join(self.installDir, 'installer/config')
self.installerPackages = os.path.join(self.installDir, 'installer/packages') self.installerPackages = os.path.join(self.installDir, 'installer/packages')
self.appIcon = os.path.join(self.rootDir, 'share/TestFrame/webcamoid.png') self.appIcon = os.path.join(self.rootDir, 'share/icons/webcamoid.png')
self.licenseFile = os.path.join(self.rootDir, 'COPYING') self.licenseFile = os.path.join(self.rootDir, 'COPYING')
self.installerScript = os.path.join(self.rootDir, 'ports/deploy/installscript.windows.qs') self.installerScript = os.path.join(self.rootDir, 'ports/deploy/installscript.windows.qs')
self.changeLog = os.path.join(self.rootDir, 'ChangeLog') self.changeLog = os.path.join(self.rootDir, 'ChangeLog')

BIN
share/TestFrame/TestFrame.bmp
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 900 KiB

39
share/TestFrame/TestFrame.py
View file

@ -1,39 +0,0 @@
#!/usr/bin/env python
#
# akvirtualcamera, virtual camera for Mac and Windows.
# Copyright (C) 2020 Gonzalo Exequiel Pedone
#
# akvirtualcamera is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# akvirtualcamera is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with akvirtualcamera. If not, see <http://www.gnu.org/licenses/>.
#
# Web-Site: http://webcamoid.github.io/
import sys
from PyQt5 import QtWidgets, QtQml, QtQuick
if __name__ =='__main__':
app = QtWidgets.QApplication(sys.argv);
engine = QtQml.QQmlApplicationEngine()
engine.load("TestFrame.qml")
def capture():
for obj in engine.rootObjects():
image = obj.grabWindow()
image.save("TestFrame.bmp")
obj.close()
for obj in engine.rootObjects():
obj.sceneGraphInitialized.connect(capture)
app.exec_()

194
share/TestFrame/TestFrame.qml
View file

@ -1,194 +0,0 @@
/* akvirtualcamera, virtual camera for Mac and Windows.
* Copyright (C) 2020 Gonzalo Exequiel Pedone
*
* akvirtualcamera is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* akvirtualcamera is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with akvirtualcamera. If not, see <http://www.gnu.org/licenses/>.
*
* Web-Site: http://webcamoid.github.io/
*/
import QtQuick 2.12
import QtQuick.Window 2.12
import QtQuick.Controls 2.5
import QtQuick.Layouts 1.3
ApplicationWindow {
width: 640
height: 480
color: "#3f2a7e"
visible: true
property int patternSize: 24
ColumnLayout {
anchors.verticalCenter: parent.verticalCenter
anchors.horizontalCenter: parent.horizontalCenter
GridLayout {
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
columns: 2
// Info
Image {
id: icon
width: 128
height: width
sourceSize.width: width
sourceSize.height: height
source: "webcamoid.png"
}
ColumnLayout {
Text {
id: programName
color: "#ffffff"
text: "Webcamoid"
font.weight: Font.Bold
font.pixelSize: 40
}
Text {
color: "#ffffff"
text: "The ultimate webcam suite!"
leftPadding: 24
font.weight: Font.Bold
font.pixelSize: 0.5 * programName.font.pixelSize
}
}
// Color pattern
GridLayout {
columns: 8
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
Layout.columnSpan: 2
Text {
text: "R"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "G"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "B"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "C"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "M"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "Y"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "K"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
Text {
text: "W"
color: "#ffffff"
font.pixelSize: 0.3 * programName.font.pixelSize
Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter
}
// RGB
Rectangle {
color: "#ff0000"
width: patternSize
height: patternSize
}
Rectangle {
color: "#00ff00"
width: patternSize
height: patternSize
}
Rectangle {
color: "#0000ff"
width: patternSize
height: patternSize
}
// CMY
Rectangle {
color: "#00ffff"
width: patternSize
height: patternSize
}
Rectangle {
color: "#ff00ff"
width: patternSize
height: patternSize
}
Rectangle {
color: "#ffff00"
width: patternSize
height: patternSize
}
// BW
Rectangle {
color: "#000000"
width: patternSize
height: patternSize
}
Rectangle {
color: "#ffffff"
width: patternSize
height: patternSize
}
}
}
// Usage
Rectangle {
width: 500
height: 125
color: "#00000000"
Text {
id: usage
color: "#ffffff"
text: "This is a Webcamoid's virtual webcam device.\n"
+ "Go to Webcamoid, enable virtual webcam output, select "
+ "this device and play some webcam, desktop or video."
wrapMode: Text.WordWrap
anchors.fill: parent
topPadding: 8
Layout.columnSpan: 2
font.pixelSize: 0.45 * programName.font.pixelSize
}
}
}
}

0
share/TestFrame/webcamoid.png → share/icons/webcamoid.png
View file

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB