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

Improved log system.

Browse source
This commit is contained in:
Gonzalo Exequiel Pedone 2020-06-29 13:17:34 -03:00
parent a1d4747900
commit fd0c716c50
No known key found for this signature in database
GPG key ID: B8B09E63E9B85BAF
59 changed files with 1620 additions and 1447 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Manager/Manager.pro
View file

@ -28,7 +28,6 @@ exists(commons.pri) {
win32: include(../dshow/dshow.pri)
macx: include(../cmio/cmio.pri)
include(../VCamUtils/VCamUtils.pri)
TEMPLATE = app
CONFIG += console link_prl

2
VCamUtils/VCamUtils.pro
View file

@ -26,8 +26,6 @@ exists(commons.pri) {
}
}
include(VCamUtils.pri)
CONFIG += \
staticlib \
create_prl \

142
VCamUtils/src/logger/logger.cpp
View file

@ -20,32 +20,45 @@
#include <chrono>
#include <ctime>
#include <fstream>
#include <map>
#include <sstream>
#include <thread>
#include "logger.h"
#include "../utils.h"
#ifdef QT_DEBUG
namespace AkVCam
{
class LoggerPrivate: public std::streambuf
class LoggerPrivate
{
public:
std::ostream *outs;
std::string logFile;
std::string fileName;
std::fstream logFile;
Logger::LogCallback logCallback;
int logLevel {AKVCAM_LOGLEVEL_DEFAULT};
std::fstream stream;
LoggerPrivate();
~LoggerPrivate() override;
static std::string logLevelString(int logLevel)
{
static std::map<int, std::string> llsMap {
{AKVCAM_LOGLEVEL_DEFAULT , "default" },
{AKVCAM_LOGLEVEL_EMERGENCY, "emergency"},
{AKVCAM_LOGLEVEL_FATAL , "fatal" },
{AKVCAM_LOGLEVEL_CRITICAL , "critical" },
{AKVCAM_LOGLEVEL_ERROR , "error" },
{AKVCAM_LOGLEVEL_WARNING , "warning" },
{AKVCAM_LOGLEVEL_NOTICE , "notice" },
{AKVCAM_LOGLEVEL_INFO , "info" },
{AKVCAM_LOGLEVEL_DEBUG , "debug" },
};
protected:
std::streamsize xsputn(const char *s, std::streamsize n) override;
if (llsMap.count(logLevel) < 1)
return {};
return llsMap[logLevel];
}
};
inline LoggerPrivate *loggerPrivate()
LoggerPrivate *loggerPrivate()
{
static LoggerPrivate logger;
@ -53,91 +66,76 @@ namespace AkVCam
}
}
void AkVCam::Logger::start(const std::string &fileName,
const std::string &extension)
std::string AkVCam::Logger::logFile()
{
stop();
loggerPrivate()->fileName =
fileName + "-" + timeStamp() + "." + extension;
return loggerPrivate()->logFile;
}
void AkVCam::Logger::start(LogCallback callback)
void AkVCam::Logger::setLogFile(const std::string &fileName)
{
stop();
loggerPrivate()->logCallback = callback;
loggerPrivate()->logFile = fileName;
auto index = fileName.rfind('.');
if (index == fileName.npos) {
loggerPrivate()->fileName = fileName + "-" + timeStamp();
} else {
std::string fname = fileName.substr(0, index);
std::string extension = fileName.substr(index + 1);
loggerPrivate()->fileName = fname + "-" + timeStamp() + "." + extension;
}
}
std::string AkVCam::Logger::header()
int AkVCam::Logger::logLevel()
{
return loggerPrivate()->logLevel;
}
void AkVCam::Logger::setLogLevel(int logLevel)
{
loggerPrivate()->logLevel = logLevel;
}
std::string AkVCam::Logger::header(int logLevel, const std::string file, int line)
{
auto now = std::chrono::system_clock::now();
auto nowMSecs = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
auto nowMSecs =
std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
char timeStamp[256];
auto time = std::chrono::system_clock::to_time_t(now);
strftime(timeStamp, 256, "%Y-%m-%d %H:%M:%S", std::localtime(&time));
std::stringstream ss;
ss << "["
<< timeStamp
<< "." << nowMSecs.count() % 1000 << ", " << std::this_thread::get_id() << "] ";
<< "."
<< nowMSecs.count() % 1000
<< ", "
<< std::this_thread::get_id()
<< ", "
<< file
<< " ("
<< line
<< ")] "
<< LoggerPrivate::logLevelString(logLevel) << ": ";
return ss.str();
}
std::ostream &AkVCam::Logger::out()
std::ostream &AkVCam::Logger::log(int logLevel)
{
if (loggerPrivate()->logCallback.second)
return *loggerPrivate()->outs;
static std::ostream dummy(nullptr);
if (logLevel > loggerPrivate()->logLevel)
return dummy;
if (loggerPrivate()->fileName.empty())
return std::cout;
if (!loggerPrivate()->logFile.is_open())
loggerPrivate()->logFile.open(loggerPrivate()->fileName,
std::ios_base::out
| std::ios_base::app);
if (!loggerPrivate()->stream.is_open())
loggerPrivate()->stream.open(loggerPrivate()->fileName,
std::ios_base::out | std::ios_base::app);
if (!loggerPrivate()->logFile.is_open())
if (!loggerPrivate()->stream.is_open())
return std::cout;
return loggerPrivate()->logFile;
return loggerPrivate()->stream;
}
void AkVCam::Logger::log()
{
tlog(header());
}
void AkVCam::Logger::tlog()
{
out() << std::endl;
}
void AkVCam::Logger::stop()
{
loggerPrivate()->fileName = {};
if (loggerPrivate()->logFile.is_open())
loggerPrivate()->logFile.close();
loggerPrivate()->logCallback = {nullptr, nullptr};
}
AkVCam::LoggerPrivate::LoggerPrivate():
outs(new std::ostream(this)),
logCallback({nullptr, nullptr})
{
}
AkVCam::LoggerPrivate::~LoggerPrivate()
{
delete this->outs;
}
std::streamsize AkVCam::LoggerPrivate::xsputn(const char *s, std::streamsize n)
{
if (this->logCallback.second)
this->logCallback.second(this->logCallback.first, s, size_t(n));
return std::streambuf::xsputn(s, n);
}
#endif

71
VCamUtils/src/logger/logger.h
View file

@ -24,44 +24,45 @@
#include "../utils.h"
#ifdef QT_DEBUG
#define AkLoggerStart(...) AkVCam::Logger::start(__VA_ARGS__)
#define AkLoggerLog(...) AkVCam::Logger::log(__VA_ARGS__)
#define AkLoggerStop() AkVCam::Logger::stop()
#define AKVCAM_LOGLEVEL_DEFAULT -1
#define AKVCAM_LOGLEVEL_EMERGENCY 0
#define AKVCAM_LOGLEVEL_FATAL 1
#define AKVCAM_LOGLEVEL_CRITICAL 2
#define AKVCAM_LOGLEVEL_ERROR 3
#define AKVCAM_LOGLEVEL_WARNING 4
#define AKVCAM_LOGLEVEL_NOTICE 5
#define AKVCAM_LOGLEVEL_INFO 6
#define AKVCAM_LOGLEVEL_DEBUG 7
namespace AkVCam
{
namespace Logger
{
AKVCAM_CALLBACK(Log, const char *data, size_t size)
#define AkLog(level) AkVCam::Logger::log(level) << AkVCam::Logger::header(level, __FILE__, __LINE__)
#define AkLogEmergency() AkLog(AKVCAM_LOGLEVEL_EMERGENCY)
#define AkLogFatal() AkLog(AKVCAM_LOGLEVEL_FATAL)
#define AkLogCritical() AkLog(AKVCAM_LOGLEVEL_CRITICAL)
#define AkLogError() AkLog(AKVCAM_LOGLEVEL_ERROR)
#define AkLogWarning() AkLog(AKVCAM_LOGLEVEL_WARNING)
#define AkLogNotice() AkLog(AKVCAM_LOGLEVEL_NOTICE)
#define AkLogInfo() AkLog(AKVCAM_LOGLEVEL_INFO)
#define AkLogDebug() AkLog(AKVCAM_LOGLEVEL_DEBUG)
void start(const std::string &fileName=std::string(),
const std::string &extension=std::string());
void start(LogCallback callback);
std::string header();
std::ostream &out();
void log();
void tlog();
void stop();
template<typename First, typename... Next>
void tlog(const First &first, const Next &... next)
{
out() << first;
tlog(next...);
}
template<typename... Param>
void log(const Param &... param)
{
tlog(header(), " ", param...);
}
}
}
#if defined(__GNUC__) || defined(__clang__)
# define AkLogFunction() AkLogDebug() << __PRETTY_FUNCTION__ << std::endl
#elif defined(_MSC_VER)
# define AkLogFunction() AkLogDebug() << __FUNCSIG__ << std::endl
#else
#define AkLoggerStart(...)
#define AkLoggerLog(...)
#define AkLoggerStop()
# define AkLogFunction() AkLogDebug() << __FUNCTION__ << "()" << std::endl
#endif
namespace AkVCam
{
namespace Logger
{
std::string logFile();
void setLogFile(const std::string &fileName);
int logLevel();
void setLogLevel(int logLevel);
std::string header(int logLevel, const std::string file, int line);
std::ostream &log(int logLevel);
}
}
#endif // AKVCAMUTILS_LOGGER_H

3
akvirtualcamera.pro
View file

@ -16,9 +16,6 @@
#
# Web-Site: http://webcamoid.github.io/
win32: include(dshow/dshow.pri)
macx: include(cmio/cmio.pri)
TEMPLATE = subdirs
CONFIG += ordered

3
cmio/Assistant/Assistant.pro
View file

@ -27,7 +27,6 @@ exists(commons.pri) {
}
include(../cmio.pri)
include(../../VCamUtils/VCamUtils.pri)
CONFIG += console link_prl
CONFIG -= app_bundle
@ -42,6 +41,7 @@ SOURCES += \
src/assistant.cpp
LIBS += \
-L$${OUT_PWD}/../PlatformUtils/$${BIN_DIR} -lPlatformUtils \
-L$${OUT_PWD}/../../VCamUtils/$${BIN_DIR} -lVCamUtils \
-framework CoreFoundation
@ -50,6 +50,7 @@ HEADERS += \
src/assistant.h
INCLUDEPATH += \
.. \
../..
INSTALLPATH = $${CMIO_PLUGIN_NAME}.plugin/Contents/Resources

691
cmio/Assistant/src/assistant.cpp
View file

@ -25,20 +25,16 @@
#include "assistant.h"
#include "assistantglobals.h"
#include "PlatformUtils/src/preferences.h"
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/image/videoformat.h"
#include "VCamUtils/src/image/videoframe.h"
#include "VCamUtils/src/logger/logger.h"
#define AkAssistantLogMethod() \
AkLoggerLog("Assistant::", __FUNCTION__, "()")
#define AkAssistantPrivateLogMethod() \
AkLoggerLog("ServicePrivate::", __FUNCTION__, "()")
#define AKVCAM_BIND_FUNC(member) \
std::bind(&member, this, std::placeholders::_1, std::placeholders::_2)
#define PREFERENCES_ID CFSTR(AKVCAM_ASSISTANT_NAME)
#define PREFERENCES_ID CFSTR(CMIO_ASSISTANT_NAME)
namespace AkVCam
{
@ -74,48 +70,6 @@ namespace AkVCam
bool startTimer();
void stopTimer();
static void timerTimeout(CFRunLoopTimerRef timer, void *info);
std::shared_ptr<CFTypeRef> cfTypeFromStd(const std::string &str) const;
std::shared_ptr<CFTypeRef> cfTypeFromStd(const std::wstring &str) const;
std::shared_ptr<CFTypeRef> cfTypeFromStd(int num) const;
std::shared_ptr<CFTypeRef> cfTypeFromStd(double num) const;
std::string stringFromCFType(CFTypeRef cfType) const;
std::wstring wstringFromCFType(CFTypeRef cfType) const;
std::vector<std::string> preferencesKeys() const;
void preferencesWrite(const std::string &key,
const std::shared_ptr<CFTypeRef> &value) const;
void preferencesWrite(const std::string &key,
const std::string &value) const;
void preferencesWrite(const std::string &key,
const std::wstring &value) const;
void preferencesWrite(const std::string &key, int value) const;
void preferencesWrite(const std::string &key, double value) const;
std::shared_ptr<CFTypeRef> preferencesRead(const std::string &key) const;
std::string preferencesReadString(const std::string &key) const;
std::wstring preferencesReadWString(const std::string &key) const;
int preferencesReadInt(const std::string &key) const;
double preferencesReadDouble(const std::string &key) const;
void preferencesDelete(const std::string &key) const;
void preferencesDeleteAll(const std::string &key) const;
void preferencesMove(const std::string &keyFrom,
const std::string &keyTo) const;
void preferencesMoveAll(const std::string &keyFrom,
const std::string &keyTo) const;
void preferencesSync() const;
std::string preferencesAddCamera(const std::wstring &description,
const std::vector<VideoFormat> &formats);
std::string preferencesAddCamera(const std::string &path,
const std::wstring &description,
const std::vector<VideoFormat> &formats);
void preferencesRemoveCamera(const std::string &path);
size_t camerasCount() const;
std::string createDevicePath() const;
int cameraFromPath(const std::string &path) const;
bool cameraExists(const std::string &path) const;
std::wstring cameraDescription(size_t cameraIndex) const;
std::string cameraPath(size_t cameraIndex) const;
size_t formatsCount(size_t cameraIndex) const;
VideoFormat cameraFormat(size_t cameraIndex, size_t formatIndex) const;
std::vector<VideoFormat> cameraFormats(size_t cameraIndex) const;
void loadCameras();
void releaseDevicesFromPeer(const std::string &portName);
void peerDied();
@ -165,7 +119,7 @@ void AkVCam::Assistant::setTimeout(double timeout)
void AkVCam::Assistant::messageReceived(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantLogMethod();
AkLogFunction();
auto type = xpc_get_type(event);
if (type == XPC_TYPE_ERROR) {
@ -173,7 +127,7 @@ void AkVCam::Assistant::messageReceived(xpc_connection_t client,
this->d->peerDied();
} else {
auto description = xpc_copy_description(event);
AkLoggerLog("ERROR: ", description);
AkLogError() << description << std::endl;
free(description);
}
} else if (type == XPC_TYPE_DICTIONARY) {
@ -245,7 +199,7 @@ uint64_t AkVCam::AssistantPrivate::id()
bool AkVCam::AssistantPrivate::startTimer()
{
AkAssistantPrivateLogMethod();
AkLogFunction();
if (this->m_timer || this->m_timeout <= 0.0)
return false;
@ -273,7 +227,7 @@ bool AkVCam::AssistantPrivate::startTimer()
void AkVCam::AssistantPrivate::stopTimer()
{
AkAssistantPrivateLogMethod();
AkLogFunction();
if (!this->m_timer)
return;
@ -290,533 +244,27 @@ void AkVCam::AssistantPrivate::timerTimeout(CFRunLoopTimerRef timer, void *info)
{
UNUSED(timer)
UNUSED(info)
AkAssistantPrivateLogMethod();
AkLogFunction();
CFRunLoopStop(CFRunLoopGetMain());
}
std::shared_ptr<CFTypeRef> AkVCam::AssistantPrivate::cfTypeFromStd(const std::string &str) const
{
auto ref =
new CFTypeRef(CFStringCreateWithCString(kCFAllocatorDefault,
str.c_str(),
kCFStringEncodingUTF8));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::shared_ptr<CFTypeRef> AkVCam::AssistantPrivate::cfTypeFromStd(const std::wstring &str) const
{
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::AssistantPrivate::cfTypeFromStd(int num) const
{
auto ref =
new CFTypeRef(CFNumberCreate(kCFAllocatorDefault,
kCFNumberIntType,
&num));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::shared_ptr<CFTypeRef> AkVCam::AssistantPrivate::cfTypeFromStd(double num) const
{
auto ref =
new CFTypeRef(CFNumberCreate(kCFAllocatorDefault,
kCFNumberDoubleType,
&num));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::string AkVCam::AssistantPrivate::stringFromCFType(CFTypeRef cfType) const
{
auto len = size_t(CFStringGetLength(CFStringRef(cfType)));
auto data = CFStringGetCStringPtr(CFStringRef(cfType), kCFStringEncodingUTF8);
if (data)
return std::string(data, len);
auto cstr = new char[len];
CFStringGetCString(CFStringRef(cfType), cstr, CFIndex(len), kCFStringEncodingUTF8);
std::string str(cstr, len);
delete [] cstr;
return str;
}
std::wstring AkVCam::AssistantPrivate::wstringFromCFType(CFTypeRef cfType) const
{
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::vector<std::string> AkVCam::AssistantPrivate::preferencesKeys() const
{
AkAssistantPrivateLogMethod();
std::vector<std::string> keys;
auto cfKeys = CFPreferencesCopyKeyList(PREFERENCES_ID,
kCFPreferencesCurrentUser,
kCFPreferencesAnyHost);
if (cfKeys) {
auto size = CFArrayGetCount(cfKeys);
for (CFIndex i = 0; i < size; i++) {
auto key = CFStringRef(CFArrayGetValueAtIndex(cfKeys, i));
keys.push_back(this->stringFromCFType(key));
}
CFRelease(cfKeys);
}
#ifdef QT_DEBUG
AkLoggerLog("Keys: ", keys.size());
std::sort(keys.begin(), keys.end());
for (auto &key: keys)
AkLoggerLog(" ", key);
#endif
return keys;
}
void AkVCam::AssistantPrivate::preferencesWrite(const std::string &key,
const std::shared_ptr<CFTypeRef> &value) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Writing: ", key, " = ", *value);
auto cfKey = cfTypeFromStd(key);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *value, PREFERENCES_ID);
}
void AkVCam::AssistantPrivate::preferencesWrite(const std::string &key,
const std::string &value) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Writing: ", key, " = ", value);
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
void AkVCam::AssistantPrivate::preferencesWrite(const std::string &key,
const std::wstring &value) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Writing: ", key, " = ", std::string(value.begin(),
value.end()));
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
void AkVCam::AssistantPrivate::preferencesWrite(const std::string &key,
int value) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Writing: ", key, " = ", value);
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
void AkVCam::AssistantPrivate::preferencesWrite(const std::string &key,
double value) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Writing: ", key, " = ", value);
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
std::shared_ptr<CFTypeRef> AkVCam::AssistantPrivate::preferencesRead(const std::string &key) const
{
AkAssistantPrivateLogMethod();
auto cfKey = cfTypeFromStd(key);
auto cfValue = CFTypeRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
if (!cfValue)
return {};
return std::shared_ptr<CFTypeRef>(new CFTypeRef(cfValue),
[] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::string AkVCam::AssistantPrivate::preferencesReadString(const std::string &key) const
{
AkAssistantPrivateLogMethod();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFStringRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
std::string value;
if (cfValue) {
value = this->stringFromCFType(cfValue);
CFRelease(cfValue);
}
return value;
}
std::wstring AkVCam::AssistantPrivate::preferencesReadWString(const std::string &key) const
{
AkAssistantPrivateLogMethod();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFStringRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
std::wstring value;
if (cfValue) {
value = this->wstringFromCFType(cfValue);
CFRelease(cfValue);
}
return value;
}
int AkVCam::AssistantPrivate::preferencesReadInt(const std::string &key) const
{
AkAssistantPrivateLogMethod();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFNumberRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
int value = 0;
if (cfValue) {
CFNumberGetValue(cfValue, kCFNumberIntType, &value);
CFRelease(cfValue);
}
return value;
}
double AkVCam::AssistantPrivate::preferencesReadDouble(const std::string &key) const
{
AkAssistantPrivateLogMethod();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFNumberRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
double value = 0;
if (cfValue) {
CFNumberGetValue(cfValue, kCFNumberDoubleType, &value);
CFRelease(cfValue);
}
return value;
}
void AkVCam::AssistantPrivate::preferencesDelete(const std::string &key) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Deleting ", key);
auto cfKey = cfTypeFromStd(key);
CFPreferencesSetAppValue(CFStringRef(*cfKey), nullptr, PREFERENCES_ID);
}
void AkVCam::AssistantPrivate::preferencesDeleteAll(const std::string &key) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Key: ", key);
for (auto &key_: this->preferencesKeys())
if (key_.size() >= key.size() && key_.substr(0, key.size()) == key)
this->preferencesDelete(key_);
}
void AkVCam::AssistantPrivate::preferencesMove(const std::string &keyFrom,
const std::string &keyTo) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("From: ", keyFrom);
AkLoggerLog("To: ", keyTo);
auto value = this->preferencesRead(keyFrom);
if (!value)
return;
this->preferencesWrite(keyTo, value);
this->preferencesDelete(keyFrom);
}
void AkVCam::AssistantPrivate::preferencesMoveAll(const std::string &keyFrom,
const std::string &keyTo) const
{
AkAssistantPrivateLogMethod();
AkLoggerLog("From: ", keyFrom);
AkLoggerLog("to: ", keyTo);
for (auto &key: this->preferencesKeys())
if (key.size() >= keyFrom.size()
&& key.substr(0, keyFrom.size()) == keyFrom) {
if (key.size() == keyFrom.size())
this->preferencesMove(key, keyTo);
else
this->preferencesMove(key, keyTo + key.substr(keyFrom.size()));
}
}
void AkVCam::AssistantPrivate::preferencesSync() const
{
AkAssistantPrivateLogMethod();
CFPreferencesAppSynchronize(PREFERENCES_ID);
}
std::string AkVCam::AssistantPrivate::preferencesAddCamera(const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
return this->preferencesAddCamera("", description, formats);
}
std::string AkVCam::AssistantPrivate::preferencesAddCamera(const std::string &path,
const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkAssistantPrivateLogMethod();
if (!path.empty() && this->cameraExists(path))
return {};
auto path_ = path.empty()? this->createDevicePath(): path;
int cameraIndex = this->preferencesReadInt("cameras");
this->preferencesWrite("cameras", cameraIndex + 1);
this->preferencesWrite("cameras."
+ std::to_string(cameraIndex)
+ ".description",
description);
this->preferencesWrite("cameras."
+ std::to_string(cameraIndex)
+ ".path",
path_);
this->preferencesWrite("cameras."
+ std::to_string(cameraIndex)
+ ".formats",
int(formats.size()));
for (size_t i = 0; i < formats.size(); i++) {
auto &format = formats[i];
auto prefix = "cameras."
+ std::to_string(cameraIndex)
+ ".formats."
+ std::to_string(i);
auto formatStr = VideoFormat::stringFromFourcc(format.fourcc());
this->preferencesWrite(prefix + ".format", formatStr);
this->preferencesWrite(prefix + ".width", format.width());
this->preferencesWrite(prefix + ".height", format.height());
this->preferencesWrite(prefix + ".fps", format.minimumFrameRate().toString());
}
this->preferencesSync();
return path_;
}
void AkVCam::AssistantPrivate::preferencesRemoveCamera(const std::string &path)
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Device: ", path);
int cameraIndex = this->cameraFromPath(path);
if (cameraIndex < 0)
return;
auto nCameras = this->camerasCount();
this->preferencesDeleteAll("cameras." + std::to_string(cameraIndex));
for (auto i = size_t(cameraIndex + 1); i < nCameras; i++)
this->preferencesMoveAll("cameras." + std::to_string(i),
"cameras." + std::to_string(i - 1));
if (nCameras > 1)
this->preferencesWrite("cameras", int(nCameras - 1));
else
this->preferencesDelete("cameras");
this->preferencesSync();
}
size_t AkVCam::AssistantPrivate::camerasCount() const
{
AkAssistantPrivateLogMethod();
int nCameras = this->preferencesReadInt("cameras");
AkLoggerLog("Cameras: ", nCameras);
return size_t(nCameras);
}
std::string AkVCam::AssistantPrivate::createDevicePath() const
{
AkAssistantPrivateLogMethod();
// List device paths in use.
std::vector<std::string> cameraPaths;
for (size_t i = 0; i < this->camerasCount(); i++)
cameraPaths.push_back(this->cameraPath(i));
const int maxId = 64;
for (int i = 0; i < maxId; i++) {
/* There are no rules for device paths in Windows. Just append an
* incremental index to a common prefix.
*/
auto path = CMIO_PLUGIN_DEVICE_PREFIX + std::to_string(i);
// Check if the path is being used, if not return it.
if (std::find(cameraPaths.begin(),
cameraPaths.end(),
path) == cameraPaths.end())
return path;
}
return {};
}
int AkVCam::AssistantPrivate::cameraFromPath(const std::string &path) const
{
for (size_t i = 0; i < this->camerasCount(); i++)
if (this->cameraPath(i) == path && !this->cameraFormats(i).empty())
return int(i);
return -1;
}
bool AkVCam::AssistantPrivate::cameraExists(const std::string &path) const
{
for (size_t i = 0; i < this->camerasCount(); i++)
if (this->cameraPath(i) == path)
return true;
return false;
}
std::wstring AkVCam::AssistantPrivate::cameraDescription(size_t cameraIndex) const
{
return this->preferencesReadWString("cameras."
+ std::to_string(cameraIndex)
+ ".description");
}
std::string AkVCam::AssistantPrivate::cameraPath(size_t cameraIndex) const
{
return this->preferencesReadString("cameras."
+ std::to_string(cameraIndex)
+ ".path");
}
size_t AkVCam::AssistantPrivate::formatsCount(size_t cameraIndex) const
{
return size_t(this->preferencesReadInt("cameras."
+ std::to_string(cameraIndex)
+ ".formats"));
}
AkVCam::VideoFormat AkVCam::AssistantPrivate::cameraFormat(size_t cameraIndex,
size_t formatIndex) const
{
AkAssistantPrivateLogMethod();
auto prefix = "cameras."
+ std::to_string(cameraIndex)
+ ".formats."
+ std::to_string(formatIndex);
auto format = this->preferencesReadString(prefix + ".format");
auto fourcc = VideoFormat::fourccFromString(format);
int width = this->preferencesReadInt(prefix + ".width");
int height = this->preferencesReadInt(prefix + ".height");
auto fps = Fraction(this->preferencesReadString(prefix + ".fps"));
return VideoFormat(fourcc, width, height, {fps});
}
std::vector<AkVCam::VideoFormat> AkVCam::AssistantPrivate::cameraFormats(size_t cameraIndex) const
{
AkAssistantPrivateLogMethod();
std::vector<AkVCam::VideoFormat> formats;
for (size_t i = 0; i < this->formatsCount(cameraIndex); i++) {
auto videoFormat = this->cameraFormat(cameraIndex, i);
if (videoFormat)
formats.push_back(videoFormat);
}
return formats;
}
void AkVCam::AssistantPrivate::loadCameras()
{
AkAssistantPrivateLogMethod();
AkLogFunction();
for (size_t i = 0; i < this->camerasCount(); i++) {
this->m_deviceConfigs[this->cameraPath(i)] = {};
this->m_deviceConfigs[this->cameraPath(i)].description = this->cameraDescription(i);
this->m_deviceConfigs[this->cameraPath(i)].formats = this->cameraFormats(i);
for (size_t i = 0; i < Preferences::camerasCount(); i++) {
this->m_deviceConfigs[Preferences::cameraPath(i)] = {};
this->m_deviceConfigs[Preferences::cameraPath(i)].description =
Preferences::cameraDescription(i);
this->m_deviceConfigs[Preferences::cameraPath(i)].formats =
Preferences::cameraFormats(i);
}
}
void AkVCam::AssistantPrivate::releaseDevicesFromPeer(const std::string &portName)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
for (auto &config: this->m_deviceConfigs)
if (config.second.broadcaster == portName) {
@ -847,7 +295,7 @@ void AkVCam::AssistantPrivate::releaseDevicesFromPeer(const std::string &portNam
void AkVCam::AssistantPrivate::peerDied()
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::vector<AssistantPeers *> allPeers {
&this->m_clients,
@ -878,7 +326,7 @@ void AkVCam::AssistantPrivate::peerDied()
void AkVCam::AssistantPrivate::requestPort(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
bool asClient = xpc_dictionary_get_bool(event, "client");
std::string portName = asClient?
@ -886,7 +334,7 @@ void AkVCam::AssistantPrivate::requestPort(xpc_connection_t client,
AKVCAM_ASSISTANT_SERVER_NAME;
portName += std::to_string(this->id());
AkLoggerLog("Returning Port: ", portName);
AkLogInfo() << "Returning Port: " << portName << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_string(reply, "port", portName.c_str());
@ -897,7 +345,7 @@ void AkVCam::AssistantPrivate::requestPort(xpc_connection_t client,
void AkVCam::AssistantPrivate::addPort(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string portName = xpc_dictionary_get_string(event, "port");
auto endpoint = xpc_dictionary_get_value(event, "connection");
@ -920,7 +368,7 @@ void AkVCam::AssistantPrivate::addPort(xpc_connection_t client,
}
if (ok) {
AkLoggerLog("Adding Peer: ", portName);
AkLogInfo() << "Adding Peer: " << portName << std::endl;
(*peers)[portName] = connection;
this->stopTimer();
}
@ -933,8 +381,8 @@ void AkVCam::AssistantPrivate::addPort(xpc_connection_t client,
void AkVCam::AssistantPrivate::removePortByName(const std::string &portName)
{
AkAssistantPrivateLogMethod();
AkLoggerLog("Port: ", portName);
AkLogFunction();
AkLogInfo() << "Port: " << portName << std::endl;
std::vector<AssistantPeers *> allPeers {
&this->m_clients,
@ -969,7 +417,7 @@ void AkVCam::AssistantPrivate::removePort(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkAssistantPrivateLogMethod();
AkLogFunction();
this->removePortByName(xpc_dictionary_get_string(event, "port"));
}
@ -977,9 +425,9 @@ void AkVCam::AssistantPrivate::removePort(xpc_connection_t client,
void AkVCam::AssistantPrivate::deviceCreate(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string portName = xpc_dictionary_get_string(event, "port");
AkLoggerLog("Port Name: ", portName);
AkLogInfo() << "Port Name: " << portName << std::endl;
size_t len = 0;
auto data = reinterpret_cast<const wchar_t *>(xpc_dictionary_get_data(event,
"description",
@ -997,7 +445,7 @@ void AkVCam::AssistantPrivate::deviceCreate(xpc_connection_t client,
formats.push_back(VideoFormat {fourcc, width, height, {frameRate}});
}
auto deviceId = this->preferencesAddCamera(description, formats);
auto deviceId = Preferences::addCamera(description, formats);
this->m_deviceConfigs[deviceId] = {};
this->m_deviceConfigs[deviceId].description = description;
this->m_deviceConfigs[deviceId].formats = formats;
@ -1009,7 +457,7 @@ void AkVCam::AssistantPrivate::deviceCreate(xpc_connection_t client,
xpc_connection_send_message(client.second, notification);
xpc_release(notification);
AkLoggerLog("Device created: ", deviceId);
AkLogInfo() << "Device created: " << deviceId << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_string(reply, "device", deviceId.c_str());
@ -1019,7 +467,7 @@ void AkVCam::AssistantPrivate::deviceCreate(xpc_connection_t client,
void AkVCam::AssistantPrivate::deviceDestroyById(const std::string &deviceId)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
auto it = this->m_deviceConfigs.find(deviceId);
if (it != this->m_deviceConfigs.end()) {
@ -1040,25 +488,25 @@ void AkVCam::AssistantPrivate::deviceDestroy(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
this->deviceDestroyById(deviceId);
this->preferencesRemoveCamera(deviceId);
Preferences::removeCamera(deviceId);
}
void AkVCam::AssistantPrivate::setBroadcasting(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::string broadcaster = xpc_dictionary_get_string(event, "broadcaster");
bool ok = false;
if (this->m_deviceConfigs.count(deviceId) > 0)
if (this->m_deviceConfigs[deviceId].broadcaster != broadcaster) {
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
this->m_deviceConfigs[deviceId].broadcaster = broadcaster;
auto notification = xpc_copy(event);
@ -1078,7 +526,7 @@ void AkVCam::AssistantPrivate::setBroadcasting(xpc_connection_t client,
void AkVCam::AssistantPrivate::setMirroring(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
bool horizontalMirror = xpc_dictionary_get_bool(event, "hmirror");
bool verticalMirror = xpc_dictionary_get_bool(event, "vmirror");
@ -1107,7 +555,7 @@ void AkVCam::AssistantPrivate::setMirroring(xpc_connection_t client,
void AkVCam::AssistantPrivate::setScaling(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
auto scaling = Scaling(xpc_dictionary_get_int64(event, "scaling"));
bool ok = false;
@ -1133,7 +581,7 @@ void AkVCam::AssistantPrivate::setScaling(xpc_connection_t client,
void AkVCam::AssistantPrivate::setAspectRatio(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
auto aspectRatio = AspectRatio(xpc_dictionary_get_int64(event, "aspect"));
bool ok = false;
@ -1159,7 +607,7 @@ void AkVCam::AssistantPrivate::setAspectRatio(xpc_connection_t client,
void AkVCam::AssistantPrivate::setSwapRgb(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
auto swapRgb = xpc_dictionary_get_bool(event, "swap");
bool ok = false;
@ -1186,7 +634,7 @@ void AkVCam::AssistantPrivate::frameReady(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkAssistantPrivateLogMethod();
AkLogFunction();
auto reply = xpc_dictionary_create_reply(event);
bool ok = true;
@ -1211,7 +659,7 @@ void AkVCam::AssistantPrivate::frameReady(xpc_connection_t client,
void AkVCam::AssistantPrivate::listeners(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
auto listeners = xpc_array_create(nullptr, 0);
@ -1221,8 +669,8 @@ void AkVCam::AssistantPrivate::listeners(xpc_connection_t client,
xpc_array_append_value(listeners, listenerObj);
}
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Listeners: ", xpc_array_get_count(listeners));
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Listeners: " << xpc_array_get_count(listeners) << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_value(reply, "listeners", listeners);
xpc_connection_send_message(client, reply);
@ -1232,7 +680,7 @@ void AkVCam::AssistantPrivate::listeners(xpc_connection_t client,
void AkVCam::AssistantPrivate::listener(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
auto index = xpc_dictionary_get_uint64(event, "index");
std::string listener;
@ -1244,8 +692,8 @@ void AkVCam::AssistantPrivate::listener(xpc_connection_t client,
ok = true;
}
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Listener: ", listener);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Listener: " << listener << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_string(reply, "listener", listener.c_str());
xpc_dictionary_set_bool(reply, "status", ok);
@ -1256,7 +704,7 @@ void AkVCam::AssistantPrivate::listener(xpc_connection_t client,
void AkVCam::AssistantPrivate::devices(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
auto devices = xpc_array_create(nullptr, 0);
for (auto &device: this->m_deviceConfigs) {
@ -1273,15 +721,18 @@ void AkVCam::AssistantPrivate::devices(xpc_connection_t client,
void AkVCam::AssistantPrivate::description(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::wstring description;
if (this->m_deviceConfigs.count(deviceId) > 0)
description = this->m_deviceConfigs[deviceId].description;
AkLoggerLog("Description for device ", deviceId, ": ",
std::string(description.begin(), description.end()));
AkLogInfo() << "Description for device "
<< deviceId
<< ": "
<< std::string(description.begin(), description.end())
<< std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_data(reply,
"description",
@ -1294,7 +745,7 @@ void AkVCam::AssistantPrivate::description(xpc_connection_t client,
void AkVCam::AssistantPrivate::formats(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
auto formats = xpc_array_create(nullptr, 0);
@ -1317,15 +768,15 @@ void AkVCam::AssistantPrivate::formats(xpc_connection_t client,
void AkVCam::AssistantPrivate::broadcasting(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::string broadcaster;
if (this->m_deviceConfigs.count(deviceId) > 0)
broadcaster = this->m_deviceConfigs[deviceId].broadcaster;
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_string(reply, "broadcaster", broadcaster.c_str());
xpc_connection_send_message(client, reply);
@ -1335,7 +786,7 @@ void AkVCam::AssistantPrivate::broadcasting(xpc_connection_t client,
void AkVCam::AssistantPrivate::mirroring(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
bool horizontalMirror = false;
bool verticalMirror = false;
@ -1345,9 +796,9 @@ void AkVCam::AssistantPrivate::mirroring(xpc_connection_t client,
verticalMirror = this->m_deviceConfigs[deviceId].verticalMirror;
}
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Horizontal mirror: ", horizontalMirror);
AkLoggerLog("Vertical mirror: ", verticalMirror);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Horizontal mirror: " << horizontalMirror << std::endl;
AkLogInfo() << "Vertical mirror: " << verticalMirror << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_bool(reply, "hmirror", horizontalMirror);
xpc_dictionary_set_bool(reply, "vmirror", verticalMirror);
@ -1357,15 +808,15 @@ void AkVCam::AssistantPrivate::mirroring(xpc_connection_t client,
void AkVCam::AssistantPrivate::scaling(xpc_connection_t client, xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
Scaling scaling = ScalingFast;
if (this->m_deviceConfigs.count(deviceId) > 0)
scaling = this->m_deviceConfigs[deviceId].scaling;
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Scaling: ", scaling);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Scaling: " << scaling << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_int64(reply, "scaling", scaling);
xpc_connection_send_message(client, reply);
@ -1375,15 +826,15 @@ void AkVCam::AssistantPrivate::scaling(xpc_connection_t client, xpc_object_t eve
void AkVCam::AssistantPrivate::aspectRatio(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
AspectRatio aspectRatio = AspectRatioIgnore;
if (this->m_deviceConfigs.count(deviceId) > 0)
aspectRatio = this->m_deviceConfigs[deviceId].aspectRatio;
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Aspect ratio: ", aspectRatio);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Aspect ratio: " << aspectRatio << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_int64(reply, "aspect", aspectRatio);
xpc_connection_send_message(client, reply);
@ -1393,15 +844,15 @@ void AkVCam::AssistantPrivate::aspectRatio(xpc_connection_t client,
void AkVCam::AssistantPrivate::swapRgb(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
bool swapRgb = false;
if (this->m_deviceConfigs.count(deviceId) > 0)
swapRgb = this->m_deviceConfigs[deviceId].swapRgb;
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Swap RGB: ", swapRgb);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Swap RGB: " << swapRgb << std::endl;
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_bool(reply, "swap", swapRgb);
xpc_connection_send_message(client, reply);
@ -1411,7 +862,7 @@ void AkVCam::AssistantPrivate::swapRgb(xpc_connection_t client,
void AkVCam::AssistantPrivate::listenerAdd(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::string listener = xpc_dictionary_get_string(event, "listener");
bool ok = false;
@ -1441,7 +892,7 @@ void AkVCam::AssistantPrivate::listenerAdd(xpc_connection_t client,
void AkVCam::AssistantPrivate::listenerRemove(xpc_connection_t client,
xpc_object_t event)
{
AkAssistantPrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::string listener = xpc_dictionary_get_string(event, "listener");
bool ok = false;

1
cmio/Assistant/src/assistantglobals.h
View file

@ -23,7 +23,6 @@
#include <functional>
#include <xpc/xpc.h>
#define AKVCAM_ASSISTANT_NAME "org.webcamoid.cmio.AkVCam.Assistant"
#define AKVCAM_ASSISTANT_CLIENT_NAME "org.webcamoid.cmio.AkVCam.Client"
#define AKVCAM_ASSISTANT_SERVER_NAME "org.webcamoid.cmio.AkVCam.Server"

10
cmio/Assistant/src/main.cpp
View file

@ -23,14 +23,18 @@
#include "assistant.h"
#include "assistantglobals.h"
#include "PlatformUtils/src/preferences.h"
#include "VCamUtils/src/logger/logger.h"
GLOBAL_STATIC(AkVCam::Assistant, assistant)
int main(int argc, char **argv)
{
auto loglevel =
AkVCam::Preferences::readInt("loglevel", AKVCAM_LOGLEVEL_DEFAULT);
AkVCam::Logger::setLogLevel(loglevel);
auto server =
xpc_connection_create_mach_service(AKVCAM_ASSISTANT_NAME,
xpc_connection_create_mach_service(CMIO_ASSISTANT_NAME,
NULL,
XPC_CONNECTION_MACH_SERVICE_LISTENER);
@ -40,7 +44,7 @@ int main(int argc, char **argv)
for (int i = 0; i < argc; i++)
if (strcmp(argv[i], "--timeout") == 0 && i + 1 < argc) {
auto timeout = strtod(argv[i + 1], nullptr);
AkLoggerLog("Set timeout: ", timeout);
AkLogInfo() << "Set timeout: " << timeout << std::endl;
assistant()->setTimeout(timeout);
break;
@ -51,7 +55,7 @@ int main(int argc, char **argv)
if (type == XPC_TYPE_ERROR) {
auto description = xpc_copy_description(event);
AkLoggerLog("ERROR: ", description);
AkLogError() << description << std::endl;
free(description);
return;

41
VCamUtils/VCamUtils.pri → cmio/PlatformUtils/PlatformUtils.pro
View file

@ -16,9 +16,40 @@
#
# Web-Site: http://webcamoid.github.io/
DEFINES += \
QT_NAMESPACE=AkVCam
CONFIG(debug, debug|release) {
DEFINES += QT_DEBUG
exists(commons.pri) {
include(commons.pri)
} else {
exists(../../commons.pri) {
include(../../commons.pri)
} else {
error("commons.pri file not found.")
}
}
include(../cmio.pri)
CONFIG += \
staticlib \
create_prl \
no_install_prl
CONFIG -= qt
DESTDIR = $${OUT_PWD}/$${BIN_DIR}
TARGET = PlatformUtils
TEMPLATE = lib
LIBS = \
-L$${OUT_PWD}/../../VCamUtils/$${BIN_DIR} -lVCamUtils \
-framework CoreFoundation
SOURCES = \
src/preferences.cpp \
src/utils.cpp
HEADERS = \
src/preferences.h \
src/utils.h
INCLUDEPATH += ../..

430
cmio/PlatformUtils/src/preferences.cpp Normal file
View file

@ -0,0 +1,430 @@
/* 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/
*/
#include "preferences.h"
#include "utils.h"
#include "VCamUtils/src/image/videoformat.h"
#include "VCamUtils/src/logger/logger.h"
#define PREFERENCES_ID CFSTR(CMIO_ASSISTANT_NAME)
std::vector<std::string> AkVCam::Preferences::keys()
{
AkLogFunction();
std::vector<std::string> keys;
auto cfKeys = CFPreferencesCopyKeyList(PREFERENCES_ID,
kCFPreferencesCurrentUser,
kCFPreferencesAnyHost);
if (cfKeys) {
auto size = CFArrayGetCount(cfKeys);
for (CFIndex i = 0; i < size; i++) {
auto key = CFStringRef(CFArrayGetValueAtIndex(cfKeys, i));
keys.push_back(stringFromCFType(key));
}
CFRelease(cfKeys);
}
AkLogInfo() << "Keys: " << keys.size() << std::endl;
std::sort(keys.begin(), keys.end());
for (auto &key: keys)
AkLogInfo() << " " << key << std::endl;
return keys;
}
void AkVCam::Preferences::write(const std::string &key,
const std::shared_ptr<CFTypeRef> &value)
{
AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << *value << std::endl;
auto cfKey = cfTypeFromStd(key);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *value, PREFERENCES_ID);
}
void AkVCam::Preferences::write(const std::string &key,
const std::string &value)
{
AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << value << std::endl;
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
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)
{
AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << value << std::endl;
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
void AkVCam::Preferences::write(const std::string &key, double value)
{
AkLogFunction();
AkLogInfo() << "Writing: " << key << " = " << value << std::endl;
auto cfKey = cfTypeFromStd(key);
auto cfValue = cfTypeFromStd(value);
CFPreferencesSetAppValue(CFStringRef(*cfKey), *cfValue, PREFERENCES_ID);
}
std::shared_ptr<CFTypeRef> AkVCam::Preferences::read(const std::string &key)
{
AkLogFunction();
auto cfKey = cfTypeFromStd(key);
auto cfValue = CFTypeRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
if (!cfValue)
return {};
return std::shared_ptr<CFTypeRef>(new CFTypeRef(cfValue),
[] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::string AkVCam::Preferences::readString(const std::string &key,
const std::string &defaultValue)
{
AkLogFunction();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFStringRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
auto value = defaultValue;
if (cfValue) {
value = stringFromCFType(cfValue);
CFRelease(cfValue);
}
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)
{
AkLogFunction();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFNumberRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
auto value = defaultValue;
if (cfValue) {
CFNumberGetValue(cfValue, kCFNumberIntType, &value);
CFRelease(cfValue);
}
return value;
}
double AkVCam::Preferences::readDouble(const std::string &key,
double defaultValue)
{
AkLogFunction();
auto cfKey = cfTypeFromStd(key);
auto cfValue =
CFNumberRef(CFPreferencesCopyAppValue(CFStringRef(*cfKey),
PREFERENCES_ID));
auto value = defaultValue;
if (cfValue) {
CFNumberGetValue(cfValue, kCFNumberDoubleType, &value);
CFRelease(cfValue);
}
return value;
}
void AkVCam::Preferences::deleteKey(const std::string &key)
{
AkLogFunction();
AkLogInfo() << "Deleting " << key << std::endl;
auto cfKey = cfTypeFromStd(key);
CFPreferencesSetAppValue(CFStringRef(*cfKey), nullptr, PREFERENCES_ID);
}
void AkVCam::Preferences::deleteAllKeys(const std::string &key)
{
AkLogFunction();
AkLogInfo() << "Key: " << key << std::endl;
for (auto &key_: keys())
if (key_.size() >= key.size() && key_.substr(0, key.size()) == key)
deleteKey(key_);
}
void AkVCam::Preferences::move(const std::string &keyFrom,
const std::string &keyTo)
{
AkLogFunction();
AkLogInfo() << "From: " << keyFrom << std::endl;
AkLogInfo() << "To: " << keyTo << std::endl;
auto value = read(keyFrom);
if (!value)
return;
write(keyTo, value);
deleteKey(keyFrom);
}
void AkVCam::Preferences::moveAll(const std::string &keyFrom,
const std::string &keyTo)
{
AkLogFunction();
AkLogInfo() << "From: " << keyFrom << std::endl;
AkLogInfo() << "To: " << keyTo << std::endl;
for (auto &key: keys())
if (key.size() >= keyFrom.size()
&& key.substr(0, keyFrom.size()) == keyFrom) {
if (key.size() == keyFrom.size())
move(key, keyTo);
else
move(key, keyTo + key.substr(keyFrom.size()));
}
}
void AkVCam::Preferences::sync()
{
AkLogFunction();
CFPreferencesAppSynchronize(PREFERENCES_ID);
}
std::string AkVCam::Preferences::addCamera(const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
return addCamera("", description, formats);
}
std::string AkVCam::Preferences::addCamera(const std::string &path,
const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkLogFunction();
if (!path.empty() && cameraExists(path))
return {};
auto path_ = path.empty()? createDevicePath(): path;
int cameraIndex = readInt("cameras");
write("cameras", cameraIndex + 1);
write("cameras."
+ std::to_string(cameraIndex)
+ ".description",
description);
write("cameras."
+ std::to_string(cameraIndex)
+ ".path",
path_);
write("cameras."
+ std::to_string(cameraIndex)
+ ".formats",
int(formats.size()));
for (size_t i = 0; i < formats.size(); i++) {
auto &format = formats[i];
auto prefix = "cameras."
+ std::to_string(cameraIndex)
+ ".formats."
+ std::to_string(i);
auto formatStr = VideoFormat::stringFromFourcc(format.fourcc());
write(prefix + ".format", formatStr);
write(prefix + ".width", format.width());
write(prefix + ".height", format.height());
write(prefix + ".fps", format.minimumFrameRate().toString());
}
sync();
return path_;
}
void AkVCam::Preferences::removeCamera(const std::string &path)
{
AkLogFunction();
AkLogInfo() << "Device: " << path << std::endl;
int cameraIndex = cameraFromPath(path);
if (cameraIndex < 0)
return;
auto nCameras = camerasCount();
deleteAllKeys("cameras." + std::to_string(cameraIndex));
for (auto i = size_t(cameraIndex + 1); i < nCameras; i++)
moveAll("cameras." + std::to_string(i),
"cameras." + std::to_string(i - 1));
if (nCameras > 1)
write("cameras", int(nCameras - 1));
else
deleteKey("cameras");
sync();
}
size_t AkVCam::Preferences::camerasCount()
{
AkLogFunction();
int nCameras = readInt("cameras");
AkLogInfo() << "Cameras: " << nCameras << std::endl;
return size_t(nCameras);
}
std::string AkVCam::Preferences::createDevicePath()
{
AkLogFunction();
// List device paths in use.
std::vector<std::string> cameraPaths;
for (size_t i = 0; i < camerasCount(); i++)
cameraPaths.push_back(cameraPath(i));
const int maxId = 64;
for (int i = 0; i < maxId; i++) {
/* There are no rules for device paths in Windows. Just append an
* incremental index to a common prefix.
*/
auto path = CMIO_PLUGIN_DEVICE_PREFIX + std::to_string(i);
// Check if the path is being used, if not return it.
if (std::find(cameraPaths.begin(),
cameraPaths.end(),
path) == cameraPaths.end())
return path;
}
return {};
}
int AkVCam::Preferences::cameraFromPath(const std::string &path)
{
for (size_t i = 0; i < camerasCount(); i++)
if (cameraPath(i) == path && !cameraFormats(i).empty())
return int(i);
return -1;
}
bool AkVCam::Preferences::cameraExists(const std::string &path)
{
for (size_t i = 0; i < camerasCount(); i++)
if (cameraPath(i) == path)
return true;
return false;
}
std::wstring AkVCam::Preferences::cameraDescription(size_t cameraIndex)
{
return readWString("cameras."
+ std::to_string(cameraIndex)
+ ".description");
}
std::string AkVCam::Preferences::cameraPath(size_t cameraIndex)
{
return readString("cameras."
+ std::to_string(cameraIndex)
+ ".path");
}
size_t AkVCam::Preferences::formatsCount(size_t cameraIndex)
{
return size_t(readInt("cameras."
+ std::to_string(cameraIndex)
+ ".formats"));
}
AkVCam::VideoFormat AkVCam::Preferences::cameraFormat(size_t cameraIndex,
size_t formatIndex)
{
AkLogFunction();
auto prefix = "cameras."
+ std::to_string(cameraIndex)
+ ".formats."
+ std::to_string(formatIndex);
auto format = readString(prefix + ".format");
auto fourcc = VideoFormat::fourccFromString(format);
int width = readInt(prefix + ".width");
int height = readInt(prefix + ".height");
auto fps = Fraction(readString(prefix + ".fps"));
return VideoFormat(fourcc, width, height, {fps});
}
std::vector<AkVCam::VideoFormat> AkVCam::Preferences::cameraFormats(size_t cameraIndex)
{
AkLogFunction();
std::vector<AkVCam::VideoFormat> formats;
for (size_t i = 0; i < formatsCount(cameraIndex); i++) {
auto videoFormat = cameraFormat(cameraIndex, i);
if (videoFormat)
formats.push_back(videoFormat);
}
return formats;
}

70
cmio/PlatformUtils/src/preferences.h Normal file
View file

@ -0,0 +1,70 @@
/* 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/
*/
#ifndef PREFERENCES_H
#define PREFERENCES_H
#include <string>
#include <vector>
#include <CoreFoundation/CoreFoundation.h>
namespace AkVCam
{
class VideoFormat;
namespace Preferences
{
std::vector<std::string> keys();
void write(const std::string &key,
const std::shared_ptr<CFTypeRef> &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, double value);
std::shared_ptr<CFTypeRef> read(const std::string &key);
std::string readString(const std::string &key,
const std::string &defaultValue={});
std::wstring readWString(const std::string &key,
const std::wstring &defaultValue={});
int readInt(const std::string &key, int defaultValue=0);
double readDouble(const std::string &key, double defaultValue=0.0);
void deleteKey(const std::string &key);
void deleteAllKeys(const std::string &key);
void move(const std::string &keyFrom, const std::string &keyTo);
void moveAll(const std::string &keyFrom, const std::string &keyTo);
void sync();
std::string addCamera(const std::wstring &description,
const std::vector<VideoFormat> &formats);
std::string addCamera(const std::string &path,
const std::wstring &description,
const std::vector<VideoFormat> &formats);
void removeCamera(const std::string &path);
size_t camerasCount();
std::string createDevicePath();
int cameraFromPath(const std::string &path);
bool cameraExists(const std::string &path);
std::wstring cameraDescription(size_t cameraIndex);
std::string cameraPath(size_t cameraIndex);
size_t formatsCount(size_t cameraIndex);
VideoFormat cameraFormat(size_t cameraIndex, size_t formatIndex);
std::vector<VideoFormat> cameraFormats(size_t cameraIndex);
}
}
#endif // PREFERENCES_H

128
cmio/PlatformUtils/src/utils.cpp Normal file
View file

@ -0,0 +1,128 @@
/* 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/
*/
#include "utils.h"
std::shared_ptr<CFTypeRef> AkVCam::cfTypeFromStd(const std::string &str)
{
auto ref =
new CFTypeRef(CFStringCreateWithCString(kCFAllocatorDefault,
str.c_str(),
kCFStringEncodingUTF8));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
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)
{
auto ref =
new CFTypeRef(CFNumberCreate(kCFAllocatorDefault,
kCFNumberIntType,
&num));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::shared_ptr<CFTypeRef> AkVCam::cfTypeFromStd(double num)
{
auto ref =
new CFTypeRef(CFNumberCreate(kCFAllocatorDefault,
kCFNumberDoubleType,
&num));
return std::shared_ptr<CFTypeRef>(ref, [] (CFTypeRef *ptr) {
CFRelease(*ptr);
delete ptr;
});
}
std::string AkVCam::stringFromCFType(CFTypeRef cfType)
{
auto len = size_t(CFStringGetLength(CFStringRef(cfType)));
auto data = CFStringGetCStringPtr(CFStringRef(cfType),
kCFStringEncodingUTF8);
if (data)
return std::string(data, len);
auto cstr = new char[len];
CFStringGetCString(CFStringRef(cfType),
cstr,
CFIndex(len),
kCFStringEncodingUTF8);
std::string str(cstr, len);
delete [] cstr;
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));
}

38
cmio/PlatformUtils/src/utils.h Normal file
View file

@ -0,0 +1,38 @@
/* 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/
*/
#ifndef PLATFORM_UTILS_H
#define PLATFORM_UTILS_H
#include <string>
#include <CoreFoundation/CoreFoundation.h>
namespace AkVCam
{
class VideoFormat;
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(double num);
std::string stringFromCFType(CFTypeRef cfType);
std::wstring wstringFromCFType(CFTypeRef cfType);
}
#endif // PLATFORM_UTILS_H

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

@ -36,12 +36,6 @@
#include "VCamUtils/src/logger/logger.h"
#include "VCamUtils/src/utils.h"
#define AkIpcBridgeLogMethod() \
AkLoggerLog("IpcBridge::", __FUNCTION__, "()")
#define AkIpcBridgePrivateLogMethod() \
AkLoggerLog("IpcBridgePrivate::", __FUNCTION__, "()")
#define AKVCAM_BIND_FUNC(member) \
std::bind(&member, this, std::placeholders::_1, std::placeholders::_2)
@ -116,7 +110,7 @@ namespace AkVCam
AkVCam::IpcBridge::IpcBridge()
{
AkIpcBridgeLogMethod();
AkLogFunction();
this->d = new IpcBridgePrivate(this);
ipcBridgePrivate().add(this);
}
@ -136,7 +130,7 @@ std::wstring AkVCam::IpcBridge::errorMessage() const
void AkVCam::IpcBridge::setOption(const std::string &key,
const std::string &value)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (value.empty())
this->d->m_options.erase(key);
@ -146,14 +140,14 @@ void AkVCam::IpcBridge::setOption(const std::string &key,
std::vector<std::wstring> AkVCam::IpcBridge::driverPaths() const
{
AkIpcBridgeLogMethod();
AkLogFunction();
return *this->d->driverPaths();
}
void AkVCam::IpcBridge::setDriverPaths(const std::vector<std::wstring> &driverPaths)
{
AkIpcBridgeLogMethod();
AkLogFunction();
*this->d->driverPaths() = driverPaths;
}
@ -189,25 +183,25 @@ bool AkVCam::IpcBridge::setRootMethod(const std::string &rootMethod)
void AkVCam::IpcBridge::connectService(bool asClient)
{
AkIpcBridgeLogMethod();
AkLogFunction();
this->d->m_asClient = asClient;
this->registerPeer(asClient);
}
void AkVCam::IpcBridge::disconnectService()
{
AkIpcBridgeLogMethod();
AkLogFunction();
this->unregisterPeer();
this->d->m_asClient = false;
}
bool AkVCam::IpcBridge::registerPeer(bool asClient)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!asClient) {
std::string plistFile =
CMIO_DAEMONS_PATH "/" AKVCAM_ASSISTANT_NAME ".plist";
CMIO_DAEMONS_PATH "/" CMIO_ASSISTANT_NAME ".plist";
auto daemon = replace(plistFile, "~", this->d->homePath());
@ -226,7 +220,7 @@ bool AkVCam::IpcBridge::registerPeer(bool asClient)
bool status = false;
auto serverMessagePort =
xpc_connection_create_mach_service(AKVCAM_ASSISTANT_NAME,
xpc_connection_create_mach_service(CMIO_ASSISTANT_NAME,
nullptr,
0);
@ -299,7 +293,7 @@ bool AkVCam::IpcBridge::registerPeer(bool asClient)
this->d->m_messagePort = messagePort;
this->d->m_serverMessagePort = serverMessagePort;
AkLoggerLog("SUCCESSFUL");
AkLogInfo() << "SUCCESSFUL" << std::endl;
return true;
@ -310,14 +304,14 @@ registerEndPoint_failed:
if (serverMessagePort)
xpc_release(serverMessagePort);
AkLoggerLog("FAILED");
AkLogError() << "FAILED" << std::endl;
return false;
}
void AkVCam::IpcBridge::unregisterPeer()
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (this->d->m_messagePort) {
xpc_release(this->d->m_messagePort);
@ -343,7 +337,7 @@ void AkVCam::IpcBridge::unregisterPeer()
std::vector<std::string> AkVCam::IpcBridge::listDevices() const
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return {};
@ -369,19 +363,17 @@ std::vector<std::string> AkVCam::IpcBridge::listDevices() const
xpc_release(reply);
#ifdef QT_DEBUG
AkLoggerLog("Devices:");
AkLogInfo() << "Devices:" << std::endl;
for (auto &device: devices)
AkLoggerLog(" ", device);
#endif
AkLogInfo() << " " << device << std::endl;
return devices;
}
std::wstring AkVCam::IpcBridge::description(const std::string &deviceId) const
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return {};
@ -427,7 +419,7 @@ AkVCam::PixelFormat AkVCam::IpcBridge::defaultOutputPixelFormat() const
std::vector<AkVCam::VideoFormat> AkVCam::IpcBridge::formats(const std::string &deviceId) const
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return {};
@ -466,7 +458,7 @@ std::vector<AkVCam::VideoFormat> AkVCam::IpcBridge::formats(const std::string &d
std::string AkVCam::IpcBridge::broadcaster(const std::string &deviceId) const
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return {};
@ -488,15 +480,15 @@ std::string AkVCam::IpcBridge::broadcaster(const std::string &deviceId) const
std::string broadcaster = xpc_dictionary_get_string(reply, "broadcaster");
xpc_release(reply);
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
return broadcaster;
}
bool AkVCam::IpcBridge::isHorizontalMirrored(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return false;
@ -523,7 +515,7 @@ bool AkVCam::IpcBridge::isHorizontalMirrored(const std::string &deviceId)
bool AkVCam::IpcBridge::isVerticalMirrored(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return false;
@ -550,7 +542,7 @@ bool AkVCam::IpcBridge::isVerticalMirrored(const std::string &deviceId)
AkVCam::Scaling AkVCam::IpcBridge::scalingMode(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return ScalingFast;
@ -577,7 +569,7 @@ AkVCam::Scaling AkVCam::IpcBridge::scalingMode(const std::string &deviceId)
AkVCam::AspectRatio AkVCam::IpcBridge::aspectRatioMode(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return AspectRatioIgnore;
@ -604,7 +596,7 @@ AkVCam::AspectRatio AkVCam::IpcBridge::aspectRatioMode(const std::string &device
bool AkVCam::IpcBridge::swapRgb(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return false;
@ -631,7 +623,7 @@ bool AkVCam::IpcBridge::swapRgb(const std::string &deviceId)
std::vector<std::string> AkVCam::IpcBridge::listeners(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return {};
@ -658,8 +650,8 @@ std::vector<std::string> AkVCam::IpcBridge::listeners(const std::string &deviceI
xpc_release(reply);
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Listeners: ", listeners.size());
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Listeners: " << listeners.size() << std::endl;
return listeners;
}
@ -728,7 +720,7 @@ bool AkVCam::IpcBridge::canApply(AkVCam::IpcBridge::Operation operation) const
std::string AkVCam::IpcBridge::deviceCreate(const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationCreate)) {
this->d->m_error = L"The driver is in use";
@ -789,7 +781,7 @@ bool AkVCam::IpcBridge::deviceEdit(const std::string &deviceId,
const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationEdit)) {
this->d->m_error = L"The driver is in use";
@ -813,7 +805,7 @@ bool AkVCam::IpcBridge::deviceEdit(const std::string &deviceId,
bool AkVCam::IpcBridge::changeDescription(const std::string &deviceId,
const std::wstring &description)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationEdit)) {
this->d->m_error = L"The driver is in use";
@ -841,7 +833,7 @@ bool AkVCam::IpcBridge::changeDescription(const std::string &deviceId,
bool AkVCam::IpcBridge::deviceDestroy(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationDestroy)) {
this->d->m_error = L"The driver is in use";
@ -868,7 +860,7 @@ bool AkVCam::IpcBridge::deviceDestroy(const std::string &deviceId)
bool AkVCam::IpcBridge::destroyAllDevices()
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationDestroyAll)) {
this->d->m_error = L"The driver is in use";
@ -886,7 +878,7 @@ bool AkVCam::IpcBridge::deviceStart(const std::string &deviceId,
const VideoFormat &format)
{
UNUSED(format)
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return false;
@ -922,7 +914,7 @@ bool AkVCam::IpcBridge::deviceStart(const std::string &deviceId,
void AkVCam::IpcBridge::deviceStop(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return;
@ -948,7 +940,7 @@ void AkVCam::IpcBridge::deviceStop(const std::string &deviceId)
bool AkVCam::IpcBridge::write(const std::string &deviceId,
const VideoFrame &frame)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return false;
@ -1021,7 +1013,7 @@ void AkVCam::IpcBridge::setMirroring(const std::string &deviceId,
bool horizontalMirrored,
bool verticalMirrored)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return;
@ -1040,7 +1032,7 @@ void AkVCam::IpcBridge::setMirroring(const std::string &deviceId,
void AkVCam::IpcBridge::setScaling(const std::string &deviceId,
Scaling scaling)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return;
@ -1058,7 +1050,7 @@ void AkVCam::IpcBridge::setScaling(const std::string &deviceId,
void AkVCam::IpcBridge::setAspectRatio(const std::string &deviceId,
AspectRatio aspectRatio)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return;
@ -1075,7 +1067,7 @@ void AkVCam::IpcBridge::setAspectRatio(const std::string &deviceId,
void AkVCam::IpcBridge::setSwapRgb(const std::string &deviceId, bool swap)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return;
@ -1092,7 +1084,7 @@ void AkVCam::IpcBridge::setSwapRgb(const std::string &deviceId, bool swap)
bool AkVCam::IpcBridge::addListener(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return false;
@ -1120,7 +1112,7 @@ bool AkVCam::IpcBridge::addListener(const std::string &deviceId)
bool AkVCam::IpcBridge::removeListener(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->d->m_serverMessagePort)
return true;
@ -1203,7 +1195,7 @@ std::vector<AkVCam::IpcBridge *> &AkVCam::IpcBridgePrivate::bridges()
void AkVCam::IpcBridgePrivate::isAlive(xpc_connection_t client,
xpc_object_t event)
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
auto reply = xpc_dictionary_create_reply(event);
xpc_dictionary_set_bool(reply, "alive", true);
@ -1215,7 +1207,7 @@ void AkVCam::IpcBridgePrivate::deviceCreate(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string device = xpc_dictionary_get_string(event, "device");
for (auto bridge: this->m_bridges)
@ -1226,7 +1218,7 @@ void AkVCam::IpcBridgePrivate::deviceDestroy(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string device = xpc_dictionary_get_string(event, "device");
@ -1238,7 +1230,7 @@ void AkVCam::IpcBridgePrivate::frameReady(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId =
xpc_dictionary_get_string(event, "device");
@ -1273,7 +1265,7 @@ void AkVCam::IpcBridgePrivate::setBroadcasting(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId =
xpc_dictionary_get_string(event, "device");
@ -1288,7 +1280,7 @@ void AkVCam::IpcBridgePrivate::setMirror(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId =
xpc_dictionary_get_string(event, "device");
@ -1309,7 +1301,7 @@ void AkVCam::IpcBridgePrivate::setScaling(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId =
xpc_dictionary_get_string(event, "device");
@ -1324,7 +1316,7 @@ void AkVCam::IpcBridgePrivate::setAspectRatio(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId =
xpc_dictionary_get_string(event, "device");
@ -1339,7 +1331,7 @@ void AkVCam::IpcBridgePrivate::setSwapRgb(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId =
xpc_dictionary_get_string(event, "device");
@ -1353,7 +1345,7 @@ void AkVCam::IpcBridgePrivate::listenerAdd(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::string listener = xpc_dictionary_get_string(event, "listener");
@ -1366,7 +1358,7 @@ void AkVCam::IpcBridgePrivate::listenerRemove(xpc_connection_t client,
xpc_object_t event)
{
UNUSED(client)
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::string deviceId = xpc_dictionary_get_string(event, "device");
std::string listener = xpc_dictionary_get_string(event, "listener");
@ -1382,7 +1374,7 @@ void AkVCam::IpcBridgePrivate::messageReceived(xpc_connection_t client,
if (type == XPC_TYPE_ERROR) {
auto description = xpc_copy_description(event);
AkLoggerLog("ERROR: ", description);
AkLogError() << description << std::endl;
free(description);
} else if (type == XPC_TYPE_DICTIONARY) {
auto message = xpc_dictionary_get_int64(event, "message");
@ -1494,7 +1486,7 @@ bool AkVCam::IpcBridgePrivate::rm(const std::string &path) const
bool AkVCam::IpcBridgePrivate::createDaemonPlist(const std::string &fileName) const
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::fstream plistFile;
plistFile.open(fileName, std::ios_base::out);
@ -1508,7 +1500,7 @@ bool AkVCam::IpcBridgePrivate::createDaemonPlist(const std::string &fileName) co
<< "<plist version=\"1.0\">" << std::endl
<< " <dict>" << std::endl
<< " <key>Label</key>" << std::endl
<< " <string>" << AKVCAM_ASSISTANT_NAME
<< " <string>" << CMIO_ASSISTANT_NAME
<< "</string>" << std::endl
<< " <key>ProgramArguments</key>" << std::endl
<< " <array>" << std::endl
@ -1523,21 +1515,11 @@ bool AkVCam::IpcBridgePrivate::createDaemonPlist(const std::string &fileName) co
<< " </array>" << std::endl
<< " <key>MachServices</key>" << std::endl
<< " <dict>" << std::endl
<< " <key>" << AKVCAM_ASSISTANT_NAME
<< " <key>" << CMIO_ASSISTANT_NAME
<< "</key>" << std::endl
<< " <true/>" << std::endl
<< " </dict>" << std::endl;
#ifdef QT_DEBUG
std::string daemonLog = "/tmp/" AKVCAM_ASSISTANT_NAME ".log";
plistFile << " <key>StandardOutPath</key>" << std::endl
<< " <string>" << daemonLog << "</string>" << std::endl
<< " <key>StandardErrorPath</key>" << std::endl
<< " <string>" << daemonLog << "</string>" << std::endl;
#endif
plistFile << " </dict>" << std::endl
<< " </dict>" << std::endl
<< " </dict>" << std::endl
<< "</plist>" << std::endl;
return true;
@ -1545,14 +1527,14 @@ bool AkVCam::IpcBridgePrivate::createDaemonPlist(const std::string &fileName) co
bool AkVCam::IpcBridgePrivate::loadDaemon()
{
AkIpcBridgePrivateLogMethod();
auto launchctl = popen("launchctl list " AKVCAM_ASSISTANT_NAME, "r");
AkLogFunction();
auto launchctl = popen("launchctl list " CMIO_ASSISTANT_NAME, "r");
if (launchctl && !pclose(launchctl))
return true;
auto daemonsPath = replace(CMIO_DAEMONS_PATH, "~", this->homePath());
auto dstDaemonsPath = daemonsPath + "/" AKVCAM_ASSISTANT_NAME ".plist";
auto dstDaemonsPath = daemonsPath + "/" CMIO_ASSISTANT_NAME ".plist";
if (!this->fileExists(dstDaemonsPath)) {
this->m_error = L"Daemon plist does not exists";
@ -1573,8 +1555,8 @@ bool AkVCam::IpcBridgePrivate::loadDaemon()
void AkVCam::IpcBridgePrivate::unloadDaemon() const
{
AkIpcBridgePrivateLogMethod();
std::string daemonPlist = AKVCAM_ASSISTANT_NAME ".plist";
AkLogFunction();
std::string daemonPlist = CMIO_ASSISTANT_NAME ".plist";
auto daemonsPath = replace(CMIO_DAEMONS_PATH, "~", this->homePath());
auto dstDaemonsPath = daemonsPath + "/" + daemonPlist;
@ -1589,7 +1571,7 @@ void AkVCam::IpcBridgePrivate::unloadDaemon() const
bool AkVCam::IpcBridgePrivate::checkDaemon()
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
auto driverPath = this->locateDriverPath();
if (driverPath.empty()) {
@ -1637,7 +1619,7 @@ bool AkVCam::IpcBridgePrivate::checkDaemon()
}
auto daemonsPath = replace(CMIO_DAEMONS_PATH, "~", this->homePath());
auto dstDaemonsPath = daemonsPath + "/" + AKVCAM_ASSISTANT_NAME + ".plist";
auto dstDaemonsPath = daemonsPath + "/" + CMIO_ASSISTANT_NAME + ".plist";
if (!this->fileExists(dstDaemonsPath)) {
if (!this->mkpath(daemonsPath)) {
@ -1658,7 +1640,7 @@ bool AkVCam::IpcBridgePrivate::checkDaemon()
void AkVCam::IpcBridgePrivate::uninstallPlugin()
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
// Stop the daemon
this->unloadDaemon();
@ -1666,7 +1648,7 @@ void AkVCam::IpcBridgePrivate::uninstallPlugin()
// Remove the agent plist
auto daemonsPath =
replace(CMIO_DAEMONS_PATH, "~", this->homePath());
this->rm(daemonsPath + "/" AKVCAM_ASSISTANT_NAME ".plist");
this->rm(daemonsPath + "/" CMIO_ASSISTANT_NAME ".plist");
// Remove the plugin
auto driverPath = this->locateDriverPath();
@ -1684,7 +1666,7 @@ void AkVCam::IpcBridgePrivate::uninstallPlugin()
std::wstring AkVCam::IpcBridgePrivate::locateDriverPath() const
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::wstring driverPath;
for (auto it = this->driverPaths()->rbegin();
@ -1714,7 +1696,7 @@ std::wstring AkVCam::IpcBridgePrivate::locateDriverPath() const
int AkVCam::IpcBridgePrivate::sudo(const std::vector<std::string> &parameters)
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
std::stringstream ss;
ss << "osascript -e \"do shell script \\\"";
@ -1742,7 +1724,7 @@ int AkVCam::IpcBridgePrivate::sudo(const std::vector<std::string> &parameters)
auto result = pclose(sudo);
if (result)
AkLoggerLog(output);
AkLogInfo() << output << std::endl;
return result;
}

2
cmio/VirtualCamera/VirtualCamera.pro
View file

@ -27,7 +27,6 @@ exists(commons.pri) {
}
include(../cmio.pri)
include(../../VCamUtils/VCamUtils.pri)
CONFIG -= qt link_prl
CONFIG += \
@ -41,6 +40,7 @@ INCLUDEPATH += \
../..
LIBS = \
-L$${OUT_PWD}/../PlatformUtils/$${BIN_DIR} -lPlatformUtils \
-L$${OUT_PWD}/../../VCamUtils/$${BIN_DIR} -lVCamUtils \
-L$${OUT_PWD}/../VCamIPC/$${BIN_DIR} -lVCamIPC \
-framework CoreFoundation \

36
cmio/VirtualCamera/src/device.cpp
View file

@ -42,7 +42,7 @@ AkVCam::Device::~Device()
OSStatus AkVCam::Device::createObject()
{
AkObjectLogMethod();
AkLogFunction();
if (!this->m_pluginInterface
|| !*this->m_pluginInterface)
@ -59,7 +59,7 @@ OSStatus AkVCam::Device::createObject()
if (status == kCMIOHardwareNoError) {
this->m_isCreated = true;
this->m_objectID = deviceID;
AkLoggerLog("Created device: ", this->m_objectID);
AkLogInfo() << "Created device: " << this->m_objectID << std::endl;
}
return status;
@ -67,7 +67,7 @@ OSStatus AkVCam::Device::createObject()
OSStatus AkVCam::Device::registerObject(bool regist)
{
AkObjectLogMethod();
AkLogFunction();
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!this->m_isCreated
@ -96,7 +96,7 @@ OSStatus AkVCam::Device::registerObject(bool regist)
AkVCam::StreamPtr AkVCam::Device::addStream()
{
AkObjectLogMethod();
AkLogFunction();
auto stream = StreamPtr(new Stream(false, this));
if (stream->createObject() == kCMIOHardwareNoError) {
@ -111,7 +111,7 @@ AkVCam::StreamPtr AkVCam::Device::addStream()
std::list<AkVCam::StreamPtr> AkVCam::Device::addStreams(int n)
{
AkObjectLogMethod();
AkLogFunction();
std::list<StreamPtr> streams;
for (int i = 0; i < n; i++) {
@ -133,7 +133,7 @@ std::list<AkVCam::StreamPtr> AkVCam::Device::addStreams(int n)
OSStatus AkVCam::Device::registerStreams(bool regist)
{
AkObjectLogMethod();
AkLogFunction();
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!this->m_isCreated
@ -226,25 +226,23 @@ void AkVCam::Device::setSwapRgb(bool swap)
OSStatus AkVCam::Device::suspend()
{
AkObjectLogMethod();
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
OSStatus AkVCam::Device::resume()
{
AkObjectLogMethod();
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
OSStatus AkVCam::Device::startStream(CMIOStreamID stream)
{
AkObjectLogMethod();
AkLogFunction();
UInt32 isRunning = 0;
this->m_properties.getProperty(kCMIODevicePropertyDeviceIsRunning,
@ -278,7 +276,7 @@ OSStatus AkVCam::Device::startStream(CMIOStreamID stream)
OSStatus AkVCam::Device::stopStream(CMIOStreamID stream)
{
AkObjectLogMethod();
AkLogFunction();
UInt32 isRunning = 0;
this->m_properties.getProperty(kCMIODevicePropertyDeviceIsRunning,
@ -310,20 +308,18 @@ OSStatus AkVCam::Device::stopStream(CMIOStreamID stream)
OSStatus AkVCam::Device::processAVCCommand(CMIODeviceAVCCommand *ioAVCCommand)
{
AkObjectLogMethod();
UNUSED(ioAVCCommand)
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
OSStatus AkVCam::Device::processRS422Command(CMIODeviceRS422Command *ioRS422Command)
{
AkObjectLogMethod();
UNUSED(ioRS422Command)
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}

60
cmio/VirtualCamera/src/objectinterface.cpp
View file

@ -62,22 +62,25 @@ CMIOObjectPropertyAddress AkVCam::ObjectInterface::address(CMIOObjectPropertySel
void AkVCam::ObjectInterface::show()
{
AkObjectLogMethod();
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
}
Boolean AkVCam::ObjectInterface::hasProperty(const CMIOObjectPropertyAddress *address)
{
AkObjectLogMethod();
AkLogFunction();
if (!this->m_properties.getProperty(address->mSelector)) {
AkLoggerLog("Unknown property ", enumToString(address->mSelector));
AkLogWarning() << "Unknown property "
<< enumToString(address->mSelector)
<< std::endl;
return false;
}
AkLoggerLog("Found property ", enumToString(address->mSelector));
AkLogInfo() << "Found property "
<< enumToString(address->mSelector)
<< std::endl;
return true;
}
@ -85,10 +88,12 @@ Boolean AkVCam::ObjectInterface::hasProperty(const CMIOObjectPropertyAddress *ad
OSStatus AkVCam::ObjectInterface::isPropertySettable(const CMIOObjectPropertyAddress *address,
Boolean *isSettable)
{
AkObjectLogMethod();
AkLogFunction();
if (!this->m_properties.getProperty(address->mSelector)) {
AkLoggerLog("Unknown property ", enumToString(address->mSelector));
AkLogWarning() << "Unknown property "
<< enumToString(address->mSelector)
<< std::endl;
return kCMIOHardwareUnknownPropertyError;
}
@ -98,10 +103,11 @@ OSStatus AkVCam::ObjectInterface::isPropertySettable(const CMIOObjectPropertyAdd
if (isSettable)
*isSettable = settable;
AkLoggerLog("Is property ",
enumToString(address->mSelector),
" settable? ",
(settable? "YES": "NO"));
AkLogInfo() << "Is property "
<< enumToString(address->mSelector)
<< " settable? "
<< (settable? "YES": "NO")
<< std::endl;
return kCMIOHardwareNoError;
}
@ -111,15 +117,19 @@ OSStatus AkVCam::ObjectInterface::getPropertyDataSize(const CMIOObjectPropertyAd
const void *qualifierData,
UInt32 *dataSize)
{
AkObjectLogMethod();
AkLoggerLog("Getting property size ", enumToString(address->mSelector));
AkLogFunction();
AkLogInfo() << "Getting property size "
<< enumToString(address->mSelector)
<< std::endl;
if (!this->m_properties.getProperty(address->mSelector,
qualifierDataSize,
qualifierData,
0,
dataSize)) {
AkLoggerLog("Unknown property ", enumToString(address->mSelector));
AkLogWarning() << "Unknown property "
<< enumToString(address->mSelector)
<< std::endl;
return kCMIOHardwareUnknownPropertyError;
}
@ -134,8 +144,10 @@ OSStatus AkVCam::ObjectInterface::getPropertyData(const CMIOObjectPropertyAddres
UInt32 *dataUsed,
void *data)
{
AkObjectLogMethod();
AkLoggerLog("Getting property ", enumToString(address->mSelector));
AkLogFunction();
AkLogInfo() << "Getting property"
<< enumToString(address->mSelector)
<< std::endl;
if (!this->m_properties.getProperty(address->mSelector,
qualifierDataSize,
@ -143,7 +155,9 @@ OSStatus AkVCam::ObjectInterface::getPropertyData(const CMIOObjectPropertyAddres
dataSize,
dataUsed,
data)) {
AkLoggerLog("Unknown property ", enumToString(address->mSelector));
AkLogWarning() << "Unknown property "
<< enumToString(address->mSelector)
<< std::endl;
return kCMIOHardwareUnknownPropertyError;
}
@ -157,15 +171,19 @@ OSStatus AkVCam::ObjectInterface::setPropertyData(const CMIOObjectPropertyAddres
UInt32 dataSize,
const void *data)
{
AkObjectLogMethod();
AkLoggerLog("Setting property ", enumToString(address->mSelector));
AkLogFunction();
AkLogInfo() << "Setting property "
<< enumToString(address->mSelector)
<< std::endl;
UNUSED(qualifierDataSize)
UNUSED(qualifierData)
if (!this->m_properties.setProperty(address->mSelector,
dataSize,
data)) {
AkLoggerLog("Unknown property ", enumToString(address->mSelector));
AkLogWarning() << "Unknown property "
<< enumToString(address->mSelector)
<< std::endl;
return kCMIOHardwareUnknownPropertyError;
}

8
cmio/VirtualCamera/src/objectinterface.h
View file

@ -26,14 +26,6 @@
#include "objectproperties.h"
#include "VCamUtils/src/utils.h"
#define AkObjectLogMethod() \
AkLoggerLog(this->m_className, \
"(", \
this->m_objectID, \
")::", \
__FUNCTION__, \
"()")
namespace AkVCam
{
class ObjectInterface

19
cmio/VirtualCamera/src/plugin.cpp
View file

@ -19,6 +19,7 @@
#include "plugin.h"
#include "utils.h"
#include "PlatformUtils/src/preferences.h"
#include "VCamUtils/src/ipcbridge.h"
#include "VCamUtils/src/logger/logger.h"
@ -26,14 +27,20 @@ extern "C" void *akPluginMain(CFAllocatorRef allocator,
CFUUIDRef requestedTypeUUID)
{
UNUSED(allocator)
auto logLevel =
AkVCam::Preferences::readInt("loglevel", AKVCAM_LOGLEVEL_DEFAULT);
AkVCam::Logger::setLogLevel(logLevel);
#if defined(QT_DEBUG) && 0
// Turn on lights
freopen("/dev/tty", "a", stdout);
freopen("/dev/tty", "a", stderr);
#endif
if (AkVCam::Logger::logLevel() > AKVCAM_LOGLEVEL_DEFAULT) {
// Turn on lights
freopen("/dev/tty", "a", stdout);
freopen("/dev/tty", "a", stderr);
}
AkLoggerStart("/tmp/" CMIO_PLUGIN_NAME, "log");
auto logFile =
AkVCam::Preferences::readString("logfile",
"/tmp/" CMIO_PLUGIN_NAME ".log");
AkVCam::Logger::setLogFile(logFile);
if (!CFEqual(requestedTypeUUID, kCMIOHardwarePlugInTypeID))
return nullptr;

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

@ -29,12 +29,6 @@
#include "VCamUtils/src/ipcbridge.h"
#include "VCamUtils/src/logger/logger.h"
#define AkPluginPrivateIntefaceLog() \
AkLoggerLog("PluginInterfacePrivate::", __FUNCTION__, "()")
#define AkPluginPrivateIntefaceLogID(x) \
AkLoggerLog("PluginInterfacePrivate::", __FUNCTION__, "(id = ", x, ")")
namespace AkVCam
{
struct PluginInterfacePrivate
@ -165,7 +159,7 @@ AkVCam::PluginInterface::PluginInterface():
auto homePath = std::string("/Users/") + getenv("USER");
std::stringstream ss;
ss << CMIO_DAEMONS_PATH << "/" << AKVCAM_ASSISTANT_NAME << ".plist";
ss << CMIO_DAEMONS_PATH << "/" << CMIO_ASSISTANT_NAME << ".plist";
auto daemon = ss.str();
if (daemon[0] == '~')
@ -201,7 +195,7 @@ CMIOObjectID AkVCam::PluginInterface::objectID() const
CMIOHardwarePlugInRef AkVCam::PluginInterface::create()
{
AkLoggerLog("Creating plugin interface.");
AkLogFunction();
auto pluginInterface = new PluginInterface();
pluginInterface->d->AddRef(pluginInterface->d);
@ -220,14 +214,14 @@ AkVCam::Object *AkVCam::PluginInterface::findObject(CMIOObjectID objectID)
HRESULT AkVCam::PluginInterface::QueryInterface(REFIID uuid, LPVOID *interface)
{
AkLogFunction();
if (!interface)
return E_POINTER;
AkLoggerLog("AkVCam::PluginInterface::QueryInterface");
if (uuidEqual(uuid, kCMIOHardwarePlugInInterfaceID)
|| uuidEqual(uuid, IUnknownUUID)) {
AkLoggerLog("Found plugin interface.");
AkLogInfo() << "Found plugin interface." << std::endl;
this->d->AddRef(this->d);
*interface = this->d;
@ -239,27 +233,18 @@ HRESULT AkVCam::PluginInterface::QueryInterface(REFIID uuid, LPVOID *interface)
OSStatus AkVCam::PluginInterface::Initialize()
{
AkLoggerLog("AkVCam::PluginInterface::Initialize");
AkLogFunction();
return this->InitializeWithObjectID(kCMIOObjectUnknown);
}
OSStatus AkVCam::PluginInterface::InitializeWithObjectID(CMIOObjectID objectID)
{
AkLoggerLog("AkVCam::PluginInterface::InitializeWithObjectID: ", objectID);
AkLogFunction();
AkLogInfo() << objectID << std::endl;
this->m_objectID = objectID;
#if defined(QT_DEBUG) && 0
std::vector<VideoFormat> formats {
{PixelFormatRGB32, 640, 480, {30.0}}
};
this->createDevice("org.webcamoid.cmio.AkVCam.Driver.Debug",
"Virtual Debug Camera (driver side)",
formats);
#endif
for (auto deviceId: this->d->m_ipcBridge.listDevices())
this->deviceAdded(this, deviceId);
@ -268,7 +253,7 @@ OSStatus AkVCam::PluginInterface::InitializeWithObjectID(CMIOObjectID objectID)
OSStatus AkVCam::PluginInterface::Teardown()
{
AkLoggerLog("AkVCam::PluginInterface::Teardown");
AkLogFunction();
return kCMIOHardwareNoError;
}
@ -276,7 +261,7 @@ OSStatus AkVCam::PluginInterface::Teardown()
void AkVCam::PluginInterface::serverStateChanged(void *userData,
IpcBridge::ServerState state)
{
AkLoggerLog("AkVCam::PluginInterface::frameReady");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -289,8 +274,8 @@ void AkVCam::PluginInterface::serverStateChanged(void *userData,
void AkVCam::PluginInterface::deviceAdded(void *userData,
const std::string &deviceId)
{
AkLoggerLog("AkVCam::PluginInterface::deviceAdded");
AkLoggerLog("Device Added: ", deviceId);
AkLogFunction();
AkLogInfo() << "Device Added: " << deviceId << std::endl;
auto self = reinterpret_cast<PluginInterface *>(userData);
auto description = self->d->m_ipcBridge.description(deviceId);
@ -302,8 +287,8 @@ void AkVCam::PluginInterface::deviceAdded(void *userData,
void AkVCam::PluginInterface::deviceRemoved(void *userData,
const std::string &deviceId)
{
AkLoggerLog("AkVCam::PluginInterface::deviceRemoved");
AkLoggerLog("Device Removed: ", deviceId);
AkLogFunction();
AkLogInfo() << "Device Removed: " << deviceId << std::endl;
auto self = reinterpret_cast<PluginInterface *>(userData);
self->destroyDevice(deviceId);
@ -313,7 +298,7 @@ void AkVCam::PluginInterface::frameReady(void *userData,
const std::string &deviceId,
const VideoFrame &frame)
{
AkLoggerLog("AkVCam::PluginInterface::frameReady");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -325,9 +310,9 @@ void AkVCam::PluginInterface::setBroadcasting(void *userData,
const std::string &deviceId,
const std::string &broadcaster)
{
AkLoggerLog("AkVCam::PluginInterface::setBroadcasting");
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogFunction();
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -340,7 +325,7 @@ void AkVCam::PluginInterface::setMirror(void *userData,
bool horizontalMirror,
bool verticalMirror)
{
AkLoggerLog("AkVCam::PluginInterface::setMirror");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -352,7 +337,7 @@ void AkVCam::PluginInterface::setScaling(void *userData,
const std::string &deviceId,
Scaling scaling)
{
AkLoggerLog("AkVCam::PluginInterface::setScaling");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -364,7 +349,7 @@ void AkVCam::PluginInterface::setAspectRatio(void *userData,
const std::string &deviceId,
AspectRatio aspectRatio)
{
AkLoggerLog("AkVCam::PluginInterface::setAspectRatio");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -376,7 +361,7 @@ void AkVCam::PluginInterface::setSwapRgb(void *userData,
const std::string &deviceId,
bool swap)
{
AkLoggerLog("AkVCam::PluginInterface::setSwapRgb");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
for (auto device: self->m_devices)
@ -387,7 +372,7 @@ void AkVCam::PluginInterface::setSwapRgb(void *userData,
void AkVCam::PluginInterface::addListener(void *userData,
const std::string &deviceId)
{
AkLoggerLog("AkVCam::PluginInterface::addListener");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
self->d->m_ipcBridge.addListener(deviceId);
}
@ -395,7 +380,7 @@ void AkVCam::PluginInterface::addListener(void *userData,
void AkVCam::PluginInterface::removeListener(void *userData,
const std::string &deviceId)
{
AkLoggerLog("AkVCam::PluginInterface::removeListener");
AkLogFunction();
auto self = reinterpret_cast<PluginInterface *>(userData);
self->d->m_ipcBridge.removeListener(deviceId);
}
@ -404,8 +389,7 @@ bool AkVCam::PluginInterface::createDevice(const std::string &deviceId,
const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkLoggerLog("AkVCam::PluginInterface::createDevice");
AkLogFunction();
StreamPtr stream;
// Create one device.
@ -488,7 +472,7 @@ createDevice_failed:
void AkVCam::PluginInterface::destroyDevice(const std::string &deviceId)
{
AkLoggerLog("AkVCam::PluginInterface::destroyDevice");
AkLogFunction();
for (auto it = this->m_devices.begin(); it != this->m_devices.end(); it++) {
auto device = *it;
@ -524,7 +508,7 @@ HRESULT AkVCam::PluginInterfacePrivate::QueryInterface(void *self,
REFIID uuid,
LPVOID *interface)
{
AkPluginPrivateIntefaceLog();
AkLogFunction();
if (!self)
return E_FAIL;
@ -536,7 +520,7 @@ HRESULT AkVCam::PluginInterfacePrivate::QueryInterface(void *self,
ULONG AkVCam::PluginInterfacePrivate::AddRef(void *self)
{
AkPluginPrivateIntefaceLog();
AkLogFunction();
if (!self)
return 0;
@ -549,7 +533,7 @@ ULONG AkVCam::PluginInterfacePrivate::AddRef(void *self)
ULONG AkVCam::PluginInterfacePrivate::Release(void *self)
{
AkPluginPrivateIntefaceLog();
AkLogFunction();
if (!self)
return 0;
@ -571,7 +555,7 @@ ULONG AkVCam::PluginInterfacePrivate::Release(void *self)
OSStatus AkVCam::PluginInterfacePrivate::Initialize(CMIOHardwarePlugInRef self)
{
AkPluginPrivateIntefaceLog();
AkLogFunction();
if (!self)
return kCMIOHardwareUnspecifiedError;
@ -584,7 +568,7 @@ OSStatus AkVCam::PluginInterfacePrivate::Initialize(CMIOHardwarePlugInRef self)
OSStatus AkVCam::PluginInterfacePrivate::InitializeWithObjectID(CMIOHardwarePlugInRef self,
CMIOObjectID objectID)
{
AkPluginPrivateIntefaceLog();
AkLogFunction();
if (!self)
return kCMIOHardwareUnspecifiedError;
@ -596,7 +580,7 @@ OSStatus AkVCam::PluginInterfacePrivate::InitializeWithObjectID(CMIOHardwarePlug
OSStatus AkVCam::PluginInterfacePrivate::Teardown(CMIOHardwarePlugInRef self)
{
AkPluginPrivateIntefaceLog();
AkLogFunction();
if (!self)
return kCMIOHardwareUnspecifiedError;
@ -609,7 +593,8 @@ OSStatus AkVCam::PluginInterfacePrivate::Teardown(CMIOHardwarePlugInRef self)
void AkVCam::PluginInterfacePrivate::ObjectShow(CMIOHardwarePlugInRef self,
CMIOObjectID objectID)
{
AkPluginPrivateIntefaceLogID(objectID);
AkLogFunction();
AkLogInfo() << "ObjectID " << objectID << std::endl;
if (!self)
return;
@ -626,7 +611,8 @@ Boolean AkVCam::PluginInterfacePrivate::ObjectHasProperty(CMIOHardwarePlugInRef
CMIOObjectID objectID,
const CMIOObjectPropertyAddress *address)
{
AkPluginPrivateIntefaceLogID(objectID);
AkLogFunction();
AkLogInfo() << "ObjectID " << objectID << std::endl;
Boolean result = false;
if (!self)
@ -647,7 +633,8 @@ OSStatus AkVCam::PluginInterfacePrivate::ObjectIsPropertySettable(CMIOHardwarePl
const CMIOObjectPropertyAddress *address,
Boolean *isSettable)
{
AkPluginPrivateIntefaceLogID(objectID);
AkLogFunction();
AkLogInfo() << "ObjectID " << objectID << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -672,7 +659,8 @@ OSStatus AkVCam::PluginInterfacePrivate::ObjectGetPropertyDataSize(CMIOHardwareP
const void *qualifierData,
UInt32 *dataSize)
{
AkPluginPrivateIntefaceLogID(objectID);
AkLogFunction();
AkLogInfo() << "ObjectID " << objectID << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -703,7 +691,8 @@ OSStatus AkVCam::PluginInterfacePrivate::ObjectGetPropertyData(CMIOHardwarePlugI
UInt32 *dataUsed,
void *data)
{
AkPluginPrivateIntefaceLogID(objectID);
AkLogFunction();
AkLogInfo() << "ObjectID " << objectID << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -737,7 +726,8 @@ OSStatus AkVCam::PluginInterfacePrivate::ObjectSetPropertyData(CMIOHardwarePlugI
UInt32 dataSize,
const void *data)
{
AkPluginPrivateIntefaceLogID(objectID);
AkLogFunction();
AkLogInfo() << "ObjectID " << objectID << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -764,7 +754,8 @@ OSStatus AkVCam::PluginInterfacePrivate::ObjectSetPropertyData(CMIOHardwarePlugI
OSStatus AkVCam::PluginInterfacePrivate::DeviceSuspend(CMIOHardwarePlugInRef self,
CMIODeviceID device)
{
AkPluginPrivateIntefaceLogID(device);
AkLogFunction();
AkLogInfo() << "DeviceID " << device << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -782,7 +773,8 @@ OSStatus AkVCam::PluginInterfacePrivate::DeviceSuspend(CMIOHardwarePlugInRef sel
OSStatus AkVCam::PluginInterfacePrivate::DeviceResume(CMIOHardwarePlugInRef self,
CMIODeviceID device)
{
AkPluginPrivateIntefaceLogID(device);
AkLogFunction();
AkLogInfo() << "DeviceID " << device << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -801,7 +793,8 @@ OSStatus AkVCam::PluginInterfacePrivate::DeviceStartStream(CMIOHardwarePlugInRef
CMIODeviceID device,
CMIOStreamID stream)
{
AkPluginPrivateIntefaceLogID(device);
AkLogFunction();
AkLogInfo() << "DeviceID " << device << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -820,7 +813,8 @@ OSStatus AkVCam::PluginInterfacePrivate::DeviceStopStream(CMIOHardwarePlugInRef
CMIODeviceID device,
CMIOStreamID stream)
{
AkPluginPrivateIntefaceLogID(device);
AkLogFunction();
AkLogInfo() << "DeviceID " << device << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -839,7 +833,8 @@ OSStatus AkVCam::PluginInterfacePrivate::DeviceProcessAVCCommand(CMIOHardwarePlu
CMIODeviceID device,
CMIODeviceAVCCommand *ioAVCCommand)
{
AkPluginPrivateIntefaceLogID(device);
AkLogFunction();
AkLogInfo() << "DeviceID " << device << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -858,7 +853,8 @@ OSStatus AkVCam::PluginInterfacePrivate::DeviceProcessRS422Command(CMIOHardwareP
CMIODeviceID device,
CMIODeviceRS422Command *ioRS422Command)
{
AkPluginPrivateIntefaceLogID(device);
AkLogFunction();
AkLogInfo() << "DeviceID " << device << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -879,7 +875,8 @@ OSStatus AkVCam::PluginInterfacePrivate::StreamCopyBufferQueue(CMIOHardwarePlugI
void *queueAlteredRefCon,
CMSimpleQueueRef *queue)
{
AkPluginPrivateIntefaceLogID(stream);
AkLogFunction();
AkLogInfo() << "StreamID " << stream << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -899,7 +896,8 @@ OSStatus AkVCam::PluginInterfacePrivate::StreamCopyBufferQueue(CMIOHardwarePlugI
OSStatus AkVCam::PluginInterfacePrivate::StreamDeckPlay(CMIOHardwarePlugInRef self,
CMIOStreamID stream)
{
AkPluginPrivateIntefaceLogID(stream);
AkLogFunction();
AkLogInfo() << "StreamID " << stream << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -917,7 +915,8 @@ OSStatus AkVCam::PluginInterfacePrivate::StreamDeckPlay(CMIOHardwarePlugInRef se
OSStatus AkVCam::PluginInterfacePrivate::StreamDeckStop(CMIOHardwarePlugInRef self,
CMIOStreamID stream)
{
AkPluginPrivateIntefaceLogID(stream);
AkLogFunction();
AkLogInfo() << "StreamID " << stream << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -936,7 +935,8 @@ OSStatus AkVCam::PluginInterfacePrivate::StreamDeckJog(CMIOHardwarePlugInRef sel
CMIOStreamID stream,
SInt32 speed)
{
AkPluginPrivateIntefaceLogID(stream);
AkLogFunction();
AkLogInfo() << "StreamID " << stream << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
@ -956,7 +956,8 @@ OSStatus AkVCam::PluginInterfacePrivate::StreamDeckCueTo(CMIOHardwarePlugInRef s
Float64 frameNumber,
Boolean playOnCue)
{
AkPluginPrivateIntefaceLogID(stream);
AkLogFunction();
AkLogInfo() << "StreamID " << stream << std::endl;
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)

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

@ -99,7 +99,7 @@ AkVCam::Stream::~Stream()
OSStatus AkVCam::Stream::createObject()
{
AkObjectLogMethod();
AkLogFunction();
if (!this->m_pluginInterface
|| !*this->m_pluginInterface
@ -117,7 +117,7 @@ OSStatus AkVCam::Stream::createObject()
if (status == kCMIOHardwareNoError) {
this->m_isCreated = true;
this->m_objectID = streamID;
AkLoggerLog("Created stream: ", this->m_objectID);
AkLogInfo() << "Created stream: " << this->m_objectID << std::endl;
}
return status;
@ -125,7 +125,7 @@ OSStatus AkVCam::Stream::createObject()
OSStatus AkVCam::Stream::registerObject(bool regist)
{
AkObjectLogMethod();
AkLogFunction();
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!this->m_isCreated
@ -155,7 +155,7 @@ OSStatus AkVCam::Stream::registerObject(bool regist)
void AkVCam::Stream::setFormats(const std::vector<VideoFormat> &formats)
{
AkObjectLogMethod();
AkLogFunction();
if (formats.empty())
return;
@ -174,15 +174,14 @@ void AkVCam::Stream::setFormats(const std::vector<VideoFormat> &formats)
formatsAdjusted.push_back(format);
}
#ifdef QT_DEBUG
for (auto &format: formatsAdjusted)
AkLoggerLog("Format: ",
enumToString(format.fourcc()),
" ",
format.width(),
"x",
format.height());
#endif
AkLogInfo() << "Format: "
<< enumToString(format.fourcc())
<< " "
<< format.width()
<< "x"
<< format.height()
<< std::endl;
this->m_properties.setProperty(kCMIOStreamPropertyFormatDescriptions,
formatsAdjusted);
@ -191,7 +190,7 @@ void AkVCam::Stream::setFormats(const std::vector<VideoFormat> &formats)
void AkVCam::Stream::setFormat(const VideoFormat &format)
{
AkObjectLogMethod();
AkLogFunction();
this->m_properties.setProperty(kCMIOStreamPropertyFormatDescription,
format);
this->m_properties.setProperty(kCMIOStreamPropertyFrameRates,
@ -213,7 +212,7 @@ void AkVCam::Stream::setFrameRate(const Fraction &frameRate)
bool AkVCam::Stream::start()
{
AkObjectLogMethod();
AkLogFunction();
if (this->d->m_running)
return false;
@ -223,14 +222,14 @@ bool AkVCam::Stream::start()
this->d->m_sequence = 0;
memset(&this->d->m_pts, 0, sizeof(CMTime));
this->d->m_running = this->d->startTimer();
AkLoggerLog("Running: ", this->d->m_running);
AkLogInfo() << "Running: " << this->d->m_running << std::endl;
return this->d->m_running;
}
void AkVCam::Stream::stop()
{
AkObjectLogMethod();
AkLogFunction();
if (!this->d->m_running)
return;
@ -248,7 +247,7 @@ bool AkVCam::Stream::running()
void AkVCam::Stream::serverStateChanged(IpcBridge::ServerState state)
{
AkObjectLogMethod();
AkLogFunction();
if (state == IpcBridge::ServerStateGone) {
this->d->m_broadcaster.clear();
@ -267,9 +266,9 @@ void AkVCam::Stream::serverStateChanged(IpcBridge::ServerState state)
void AkVCam::Stream::frameReady(const AkVCam::VideoFrame &frame)
{
AkObjectLogMethod();
AkLoggerLog("Running: ", this->d->m_running);
AkLoggerLog("Broadcaster: ", this->d->m_broadcaster);
AkLogFunction();
AkLogInfo() << "Running: " << this->d->m_running << std::endl;
AkLogInfo() << "Broadcaster: " << this->d->m_broadcaster << std::endl;
if (!this->d->m_running)
return;
@ -284,7 +283,7 @@ void AkVCam::Stream::frameReady(const AkVCam::VideoFrame &frame)
void AkVCam::Stream::setBroadcasting(const std::string &broadcaster)
{
AkObjectLogMethod();
AkLogFunction();
if (this->d->m_broadcaster == broadcaster)
return;
@ -300,7 +299,7 @@ void AkVCam::Stream::setBroadcasting(const std::string &broadcaster)
void AkVCam::Stream::setMirror(bool horizontalMirror, bool verticalMirror)
{
AkObjectLogMethod();
AkLogFunction();
if (this->d->m_horizontalMirror == horizontalMirror
&& this->d->m_verticalMirror == verticalMirror)
@ -313,7 +312,7 @@ void AkVCam::Stream::setMirror(bool horizontalMirror, bool verticalMirror)
void AkVCam::Stream::setScaling(Scaling scaling)
{
AkObjectLogMethod();
AkLogFunction();
if (this->d->m_scaling == scaling)
return;
@ -324,7 +323,7 @@ void AkVCam::Stream::setScaling(Scaling scaling)
void AkVCam::Stream::setAspectRatio(AspectRatio aspectRatio)
{
AkObjectLogMethod();
AkLogFunction();
if (this->d->m_aspectRatio == aspectRatio)
return;
@ -335,7 +334,7 @@ void AkVCam::Stream::setAspectRatio(AspectRatio aspectRatio)
void AkVCam::Stream::setSwapRgb(bool swap)
{
AkObjectLogMethod();
AkLogFunction();
if (this->d->m_swapRgb == swap)
return;
@ -348,7 +347,7 @@ OSStatus AkVCam::Stream::copyBufferQueue(CMIODeviceStreamQueueAlteredProc queueA
void *queueAlteredRefCon,
CMSimpleQueueRef *queue)
{
AkObjectLogMethod();
AkLogFunction();
this->d->m_queueAltered = queueAlteredProc;
this->d->m_queueAlteredRefCon = queueAlteredRefCon;
@ -362,39 +361,35 @@ OSStatus AkVCam::Stream::copyBufferQueue(CMIODeviceStreamQueueAlteredProc queueA
OSStatus AkVCam::Stream::deckPlay()
{
AkObjectLogMethod();
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
OSStatus AkVCam::Stream::deckStop()
{
AkObjectLogMethod();
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
OSStatus AkVCam::Stream::deckJog(SInt32 speed)
{
AkObjectLogMethod();
UNUSED(speed)
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
OSStatus AkVCam::Stream::deckCueTo(Float64 frameNumber, Boolean playOnCue)
{
AkObjectLogMethod();
UNUSED(frameNumber)
UNUSED(playOnCue)
AkLoggerLog("STUB");
AkLogFunction();
AkLogDebug() << "STUB" << std::endl;
return kCMIOHardwareUnspecifiedError;
}
@ -406,7 +401,7 @@ AkVCam::StreamPrivate::StreamPrivate(AkVCam::Stream *self):
bool AkVCam::StreamPrivate::startTimer()
{
AkLoggerLog("AkVCam::StreamPrivate::startTimer()");
AkLogFunction();
if (this->m_timer)
return false;
@ -437,7 +432,7 @@ bool AkVCam::StreamPrivate::startTimer()
void AkVCam::StreamPrivate::stopTimer()
{
AkLoggerLog("AkVCam::StreamPrivate::stopTimer()");
AkLogFunction();
if (!this->m_timer)
return;
@ -452,11 +447,11 @@ void AkVCam::StreamPrivate::stopTimer()
void AkVCam::StreamPrivate::streamLoop(CFRunLoopTimerRef timer, void *info)
{
AkLoggerLog("AkVCam::StreamPrivate::streamLoop()");
UNUSED(timer)
AkLogFunction();
auto self = reinterpret_cast<StreamPrivate *>(info);
AkLoggerLog("Running: ", self->m_running);
AkLogInfo() << "Running: " << self->m_running << std::endl;
if (!self->m_running)
return;
@ -473,7 +468,7 @@ void AkVCam::StreamPrivate::streamLoop(CFRunLoopTimerRef timer, void *info)
void AkVCam::StreamPrivate::sendFrame(const VideoFrame &frame)
{
AkLoggerLog("AkVCam::StreamPrivate::sendFrame()");
AkLogFunction();
if (this->m_queue->fullness() >= 1.0f)
return;
@ -482,12 +477,13 @@ void AkVCam::StreamPrivate::sendFrame(const VideoFrame &frame)
int width = frame.format().width();
int height = frame.format().height();
AkLoggerLog("Sending Frame: ",
enumToString(fourcc),
" ",
width,
"x",
height);
AkLogInfo() << "Sending Frame: "
<< enumToString(fourcc)
<< " "
<< width
<< "x"
<< height
<< std::endl;
bool resync = false;
auto hostTime = CFAbsoluteTimeGetCurrent();

5
cmio/cmio.pri
View file

@ -30,6 +30,8 @@ isEmpty(CMIO_PLUGIN_VENDOR):
CMIO_PLUGIN_VENDOR = "Webcamoid Project"
isEmpty(CMIO_PLUGIN_PRODUCT):
CMIO_PLUGIN_PRODUCT = $$CMIO_PLUGIN_NAME
isEmpty(CMIO_ASSISTANT_NAME):
CMIO_ASSISTANT_NAME = "org.webcamoid.cmio.AkVCam.Assistant"
DEFINES += \
CMIO_PLUGINS_DAL_PATH=\"\\\"$$CMIO_PLUGINS_DAL_PATH\\\"\" \
@ -41,4 +43,5 @@ DEFINES += \
CMIO_PLUGIN_ASSISTANT_NAME_L=\"L\\\"$$CMIO_PLUGIN_ASSISTANT_NAME\\\"\" \
CMIO_PLUGIN_DEVICE_PREFIX=\"\\\"$$CMIO_PLUGIN_DEVICE_PREFIX\\\"\" \
CMIO_PLUGIN_VENDOR=\"\\\"$$CMIO_PLUGIN_VENDOR\\\"\" \
CMIO_PLUGIN_PRODUCT=\"\\\"$$CMIO_PLUGIN_PRODUCT\\\"\"
CMIO_PLUGIN_PRODUCT=\"\\\"$$CMIO_PLUGIN_PRODUCT\\\"\" \
CMIO_ASSISTANT_NAME=\"\\\"$$CMIO_ASSISTANT_NAME\\\"\"

1
cmio/cmio.pro
View file

@ -20,6 +20,7 @@ TEMPLATE = subdirs
CONFIG += ordered
SUBDIRS = \
PlatformUtils \
VCamIPC \
Assistant \
VirtualCamera

1
commons.pri
View file

@ -65,7 +65,6 @@ COMPILER = $$join(COMPILER, _)
CONFIG(debug, debug|release) {
COMMONS_BUILD_PATH = debug/$${COMPILER}/$${TARGET_ARCH}
DEFINES += QT_DEBUG
} else {
COMMONS_BUILD_PATH = release/$$COMPILER/$${TARGET_ARCH}
}

1
dshow/Assistant/Assistant.pro
View file

@ -27,7 +27,6 @@ exists(commons.pri) {
}
include(../dshow.pri)
include(../../VCamUtils/VCamUtils.pri)
TEMPLATE = app
CONFIG += console link_prl

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

@ -26,9 +26,14 @@
int main(int argc, char **argv)
{
auto loglevel = AkVCam::regReadInt("loglevel", AKVCAM_LOGLEVEL_DEFAULT);
AkVCam::Logger::setLogLevel(loglevel);
auto temp = AkVCam::tempPath();
AkLoggerStart(std::string(temp.begin(), temp.end())
+ "\\" DSHOW_PLUGIN_ASSISTANT_NAME, "log");
auto logFile =
AkVCam::regReadString("logfile",
std::string(temp.begin(), temp.end())
+ "\\" DSHOW_PLUGIN_ASSISTANT_NAME ".log");
AkVCam::Logger::setLogFile(logFile);
AkVCam::Service service;
if (argc > 1) {
@ -49,7 +54,7 @@ int main(int argc, char **argv)
}
}
AkLoggerLog("Setting service dispatcher");
AkLogInfo() << "Setting service dispatcher" << std::endl;
WCHAR serviceName[] = TEXT(DSHOW_PLUGIN_ASSISTANT_NAME);
SERVICE_TABLE_ENTRY serviceTable[] = {
@ -58,7 +63,7 @@ int main(int argc, char **argv)
};
if (!StartServiceCtrlDispatcher(serviceTable)) {
AkLoggerLog("Service dispatcher failed");
AkLogError() << "Service dispatcher failed" << std::endl;
return EXIT_FAILURE;
}

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

@ -36,12 +36,6 @@
#include "VCamUtils/src/timer.h"
#include "VCamUtils/src/logger/logger.h"
#define AkServiceLogMethod() \
AkLoggerLog("Service::", __FUNCTION__, "()")
#define AkServicePrivateLogMethod() \
AkLoggerLog("ServicePrivate::", __FUNCTION__, "()")
namespace AkVCam
{
struct AssistantDevice
@ -126,11 +120,11 @@ AkVCam::Service::~Service()
BOOL AkVCam::Service::install()
{
AkServiceLogMethod();
AkLogFunction();
WCHAR fileName[MAX_PATH];
if (!GetModuleFileName(nullptr, fileName, MAX_PATH)) {
AkLoggerLog("Can't read module file name");
AkLogError() << "Can't read module file name" << std::endl;
return false;
}
@ -138,7 +132,7 @@ BOOL AkVCam::Service::install()
auto scManager = OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
if (!scManager) {
AkLoggerLog("Can't open SCManager");
AkLogError() << "Can't open SCManager" << std::endl;
return false;
}
@ -159,7 +153,7 @@ BOOL AkVCam::Service::install()
nullptr);
if (!service) {
AkLoggerLog("Can't create service");
AkLogError() << "Can't create service" << std::endl;
CloseServiceHandle(scManager);
return false;
@ -204,11 +198,11 @@ BOOL AkVCam::Service::install()
void AkVCam::Service::uninstall()
{
AkServiceLogMethod();
AkLogFunction();
auto scManager = OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
if (!scManager) {
AkLoggerLog("Can't open SCManager");
AkLogError() << "Can't open SCManager" << std::endl;
return;
}
@ -221,7 +215,7 @@ void AkVCam::Service::uninstall()
if (ControlService(sevice,
SERVICE_CONTROL_STOP,
&servicePrivate()->m_status)) {
AkLoggerLog("Stopping service");
AkLogInfo() << "Stopping service" << std::endl;
do {
Sleep(1000);
@ -230,12 +224,12 @@ void AkVCam::Service::uninstall()
}
if (!DeleteService(sevice)) {
AkLoggerLog("Delete service failed");
AkLogError() << "Delete service failed" << std::endl;
}
CloseServiceHandle(sevice);
} else {
AkLoggerLog("Can't open service");
AkLogError() << "Can't open service" << std::endl;
}
CloseServiceHandle(scManager);
@ -243,14 +237,14 @@ void AkVCam::Service::uninstall()
void AkVCam::Service::debug()
{
AkServiceLogMethod();
AkLogFunction();
SetConsoleCtrlHandler(controlDebugHandler, TRUE);
servicePrivate()->m_messageServer.start(true);
}
void AkVCam::Service::showHelp(int argc, char **argv)
{
AkServiceLogMethod();
AkLogFunction();
UNUSED(argc)
auto programName = strrchr(argv[0], '\\');
@ -277,7 +271,7 @@ void AkVCam::Service::showHelp(int argc, char **argv)
AkVCam::ServicePrivate::ServicePrivate()
{
AkServicePrivateLogMethod();
AkLogFunction();
this->m_status = {
SERVICE_WIN32_OWN_PROCESS,
@ -364,7 +358,7 @@ void AkVCam::ServicePrivate::checkPeers(void *userData)
self->m_peerMutex.unlock();
for (auto &port: removePorts) {
AkLoggerLog(port, " died, removing...");
AkLogWarning() << port << " died, removing..." << std::endl;
self->removePortByName(port);
}
}
@ -373,7 +367,7 @@ void AkVCam::ServicePrivate::sendStatus(DWORD currentState,
DWORD exitCode,
DWORD wait)
{
AkServicePrivateLogMethod();
AkLogFunction();
this->m_status.dwControlsAccepted =
currentState == SERVICE_START_PENDING? 0: SERVICE_ACCEPT_STOP;
@ -398,8 +392,8 @@ uint64_t AkVCam::ServicePrivate::id()
void AkVCam::ServicePrivate::removePortByName(const std::string &portName)
{
AkServicePrivateLogMethod();
AkLoggerLog("Port: ", portName);
AkLogFunction();
AkLogInfo() << "Port: " << portName << std::endl;
this->m_peerMutex.lock();
@ -463,7 +457,7 @@ void AkVCam::ServicePrivate::releaseDevicesFromPeer(const std::string &portName)
void AkVCam::ServicePrivate::requestPort(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgRequestPort>(message);
std::string portName = data->client?
@ -471,7 +465,7 @@ void AkVCam::ServicePrivate::requestPort(AkVCam::Message *message)
AKVCAM_ASSISTANT_SERVER_NAME;
portName += std::to_string(this->id());
AkLoggerLog("Returning Port: ", portName);
AkLogInfo() << "Returning Port: " << portName << std::endl;
memcpy(data->port,
portName.c_str(),
(std::min<size_t>)(portName.size(), MAX_STRING));
@ -479,7 +473,7 @@ void AkVCam::ServicePrivate::requestPort(AkVCam::Message *message)
void AkVCam::ServicePrivate::addPort(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgAddPort>(message);
std::string portName(data->port);
@ -502,7 +496,7 @@ void AkVCam::ServicePrivate::addPort(AkVCam::Message *message)
}
if (ok) {
AkLoggerLog("Adding Peer: ", portName);
AkLogInfo() << "Adding Peer: " << portName << std::endl;
(*peers)[portName] = pipeName;
}
@ -518,7 +512,7 @@ void AkVCam::ServicePrivate::addPort(AkVCam::Message *message)
void AkVCam::ServicePrivate::removePort(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgRemovePort>(message);
this->removePortByName(data->port);
@ -526,7 +520,7 @@ void AkVCam::ServicePrivate::removePort(AkVCam::Message *message)
void AkVCam::ServicePrivate::setBroadCasting(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgBroadcasting>(message);
std::string deviceId(data->device);
std::string broadcaster(data->broadcaster);
@ -538,8 +532,8 @@ void AkVCam::ServicePrivate::setBroadCasting(AkVCam::Message *message)
if (this->m_deviceConfigs[deviceId].broadcaster == broadcaster)
return;
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
this->m_deviceConfigs[deviceId].broadcaster = broadcaster;
data->status = true;
@ -555,7 +549,7 @@ void AkVCam::ServicePrivate::setBroadCasting(AkVCam::Message *message)
void AkVCam::ServicePrivate::setMirroring(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgMirroring>(message);
std::string deviceId(data->device);
data->status = false;
@ -583,7 +577,7 @@ void AkVCam::ServicePrivate::setMirroring(AkVCam::Message *message)
void AkVCam::ServicePrivate::setScaling(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgScaling>(message);
std::string deviceId(data->device);
data->status = false;
@ -609,7 +603,7 @@ void AkVCam::ServicePrivate::setScaling(AkVCam::Message *message)
void AkVCam::ServicePrivate::setAspectRatio(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgAspectRatio>(message);
std::string deviceId(data->device);
data->status = false;
@ -635,7 +629,7 @@ void AkVCam::ServicePrivate::setAspectRatio(AkVCam::Message *message)
void AkVCam::ServicePrivate::setSwapRgb(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgSwapRgb>(message);
std::string deviceId(data->device);
data->status = false;
@ -661,7 +655,7 @@ void AkVCam::ServicePrivate::setSwapRgb(AkVCam::Message *message)
void AkVCam::ServicePrivate::frameReady(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
this->m_peerMutex.lock();
for (auto &client: this->m_clients)
@ -672,7 +666,7 @@ void AkVCam::ServicePrivate::frameReady(AkVCam::Message *message)
void AkVCam::ServicePrivate::listeners(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgListeners>(message);
std::string deviceId(data->device);
@ -693,7 +687,7 @@ void AkVCam::ServicePrivate::listeners(AkVCam::Message *message)
void AkVCam::ServicePrivate::listener(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgListeners>(message);
std::string deviceId(data->device);
@ -718,7 +712,7 @@ void AkVCam::ServicePrivate::listener(AkVCam::Message *message)
void AkVCam::ServicePrivate::broadcasting(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgBroadcasting>(message);
std::string deviceId(data->device);
@ -734,7 +728,7 @@ void AkVCam::ServicePrivate::broadcasting(AkVCam::Message *message)
void AkVCam::ServicePrivate::mirroring(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgMirroring>(message);
std::string deviceId(data->device);
@ -748,7 +742,7 @@ void AkVCam::ServicePrivate::mirroring(AkVCam::Message *message)
void AkVCam::ServicePrivate::scaling(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgScaling>(message);
std::string deviceId(data->device);
@ -761,7 +755,7 @@ void AkVCam::ServicePrivate::scaling(AkVCam::Message *message)
void AkVCam::ServicePrivate::aspectRatio(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgAspectRatio>(message);
std::string deviceId(data->device);
@ -774,7 +768,7 @@ void AkVCam::ServicePrivate::aspectRatio(AkVCam::Message *message)
void AkVCam::ServicePrivate::swapRgb(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgSwapRgb>(message);
std::string deviceId(data->device);
@ -787,7 +781,7 @@ void AkVCam::ServicePrivate::swapRgb(AkVCam::Message *message)
void AkVCam::ServicePrivate::listenerAdd(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgListeners>(message);
std::string deviceId(data->device);
@ -819,7 +813,7 @@ void AkVCam::ServicePrivate::listenerAdd(AkVCam::Message *message)
void AkVCam::ServicePrivate::listenerRemove(AkVCam::Message *message)
{
AkServicePrivateLogMethod();
AkLogFunction();
auto data = messageData<MsgListeners>(message);
std::string deviceId(data->device);
@ -857,7 +851,7 @@ DWORD WINAPI controlHandler(DWORD control,
UNUSED(eventType)
UNUSED(eventData)
UNUSED(context)
AkLoggerLog("controlHandler()");
AkLogFunction();
DWORD result = ERROR_CALL_NOT_IMPLEMENTED;
@ -889,7 +883,7 @@ DWORD WINAPI controlHandler(DWORD control,
BOOL WINAPI controlDebugHandler(DWORD control)
{
AkLoggerLog("controlDebugHandler()");
AkLogFunction();
if (control == CTRL_BREAK_EVENT || control == CTRL_C_EVENT) {
AkVCam::servicePrivate()->m_messageServer.stop();
@ -904,8 +898,8 @@ void WINAPI serviceMain(DWORD dwArgc, LPTSTR *lpszArgv)
{
UNUSED(dwArgc)
UNUSED(lpszArgv)
AkLoggerLog("serviceMain()");
AkLoggerLog("Setting service control handler");
AkLogFunction();
AkLogInfo() << "Setting service control handler" << std::endl;
AkVCam::servicePrivate()->m_statusHandler =
RegisterServiceCtrlHandlerEx(TEXT(DSHOW_PLUGIN_ASSISTANT_NAME),
@ -917,7 +911,7 @@ void WINAPI serviceMain(DWORD dwArgc, LPTSTR *lpszArgv)
AkVCam::servicePrivate()->sendStatus(SERVICE_START_PENDING, NO_ERROR, 3000);
AkLoggerLog("Setting up service");
AkLogInfo() << "Setting up service" << std::endl;
AkVCam::servicePrivate()->m_messageServer
.connectStateChanged(AkVCam::servicePrivate(),
&AkVCam::ServicePrivate::stateChanged);

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

@ -28,8 +28,6 @@
#include "utils.h"
#include "VCamUtils/src/logger/logger.h"
#define AK_CUR_INTERFACE "MessageServer"
namespace AkVCam
{
class MessageServerPrivate
@ -124,16 +122,16 @@ void AkVCam::MessageServer::setHandlers(const std::map<uint32_t, MessageHandler>
bool AkVCam::MessageServer::start(bool wait)
{
AkLogMethod();
AkLogFunction();
switch (this->d->m_mode) {
case ServerModeReceive:
AkLoggerLog("Starting mode receive");
AkLogInfo() << "Starting mode receive" << std::endl;
return this->d->startReceive(wait);
case ServerModeSend:
AkLoggerLog("Starting mode send");
AkLogInfo() << "Starting mode send" << std::endl;
return this->d->startSend();
}
@ -143,7 +141,7 @@ bool AkVCam::MessageServer::start(bool wait)
void AkVCam::MessageServer::stop(bool wait)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_mode == ServerModeReceive)
this->d->stopReceive(wait);
@ -279,9 +277,10 @@ bool AkVCam::MessageServerPrivate::startReceive(bool wait)
startReceive_failed:
if (!ok) {
AkLoggerLog("Error starting server: ",
errorToString(GetLastError()),
" (", GetLastError(), ")");
AkLogError() << "Error starting server: "
<< errorToString(GetLastError())
<< " (" << GetLastError() << ")"
<< std::endl;
AKVCAM_EMIT(this->self, StateChanged, MessageServer::StateStopped)
}
@ -371,17 +370,19 @@ void AkVCam::MessageServerPrivate::checkLoop()
if (result
&& this->m_pipeState != AkVCam::MessageServer::PipeStateAvailable) {
AkLoggerLog("Pipe Available: ",
std::string(this->m_pipeName.begin(),
this->m_pipeName.end()));
AkLogInfo() << "Pipe Available: "
<< std::string(this->m_pipeName.begin(),
this->m_pipeName.end())
<< std::endl;
this->m_pipeState = AkVCam::MessageServer::PipeStateAvailable;
AKVCAM_EMIT(this->self, PipeStateChanged, this->m_pipeState);
} else if (!result
&& this->m_pipeState != AkVCam::MessageServer::PipeStateGone
&& GetLastError() != ERROR_SEM_TIMEOUT) {
AkLoggerLog("Pipe Gone: ",
std::string(this->m_pipeName.begin(),
this->m_pipeName.end()));
AkLogInfo() << "Pipe Gone: "
<< std::string(this->m_pipeName.begin(),
this->m_pipeName.end())
<< std::endl;
this->m_pipeState = AkVCam::MessageServer::PipeStateGone;
AKVCAM_EMIT(this->self, PipeStateChanged, this->m_pipeState);
}
@ -414,9 +415,10 @@ HRESULT AkVCam::MessageServerPrivate::waitResult(DWORD *bytesTransferred)
return S_FALSE;
}
} else {
AkLoggerLog("Wait result failed: ",
errorToString(lastError),
" (", lastError, ")");
AkLogWarning() << "Wait result failed: "
<< errorToString(lastError)
<< " (" << lastError << ")"
<< std::endl;
return E_FAIL;
}

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

@ -127,12 +127,13 @@ bool AkVCam::SharedMemory::open(size_t pageSize, OpenMode mode)
}
if (!this->d->m_sharedHandle) {
AkLoggerLog("Error opening shared memory (",
std::string(this->d->m_name.begin(),
this->d->m_name.end()),
"): ",
errorToString(GetLastError()),
" (", GetLastError(), ")");
AkLogError() << "Error opening shared memory ("
<< std::string(this->d->m_name.begin(),
this->d->m_name.end())
<< "): "
<< errorToString(GetLastError())
<< " (" << GetLastError() << ")"
<< std::endl;
return false;
}

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

@ -814,6 +814,53 @@ LONG AkVCam::regGetValue(HKEY hkey,
return result;
}
std::string AkVCam::regReadString(const std::string &key, const std::string &defaultValue)
{
auto wkey = std::wstring(key.begin(), key.end());
WCHAR value[MAX_PATH];
memset(value, 0, MAX_PATH * sizeof(WCHAR));
DWORD valueSize = MAX_PATH;
if (FAILED(regGetValue(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Webcamoid\\VirtualCamera",
wkey.c_str(),
RRF_RT_REG_SZ,
nullptr,
&value,
&valueSize)))
return defaultValue;
char str[MAX_PATH];
char defaultChar = '?';
WideCharToMultiByte(CP_ACP,
0,
value,
-1,
str,
MAX_PATH,
&defaultChar,
nullptr);
return std::string(str);
}
int AkVCam::regReadInt(const std::string &key, int defaultValue)
{
auto wkey = std::wstring(key.begin(), key.end());
DWORD value = 0;
DWORD valueSize = sizeof(DWORD);
if (FAILED(regGetValue(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Webcamoid\\VirtualCamera",
wkey.c_str(),
RRF_RT_REG_DWORD,
nullptr,
&value,
&valueSize)))
return defaultValue;
return value;
}
std::vector<CLSID> AkVCam::listRegisteredCameras(HINSTANCE hinstDLL)
{
WCHAR *strIID = nullptr;

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

@ -27,10 +27,7 @@
#include "VCamUtils/src/logger/logger.h"
#define AkLogInterface(interface, instance) \
AkLoggerLog("Returning ", #interface, "(", instance, ")")
#define AkLogMethod() \
AkLoggerLog(AK_CUR_INTERFACE, "(", this, ")::", __FUNCTION__, "()")
AkLogInfo() << "Returning " << #interface << "(" << instance << ")" << std::endl
namespace AkVCam
{
@ -79,6 +76,9 @@ namespace AkVCam
LPDWORD pdwType,
PVOID pvData,
LPDWORD pcbData);
std::string regReadString(const std::string &key,
const std::string &defaultValue={});
int regReadInt(const std::string &key, int defaultValue=0);
std::vector<CLSID> listRegisteredCameras(HINSTANCE hinstDLL);
DWORD camerasCount();
std::wstring createDevicePath();

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

@ -36,12 +36,6 @@
#include "VCamUtils/src/ipcbridge.h"
#include "VCamUtils/src/logger/logger.h"
#define AkIpcBridgeLogMethod() \
AkLoggerLog("IpcBridge::", __FUNCTION__, "()")
#define AkIpcBridgePrivateLogMethod() \
AkLoggerLog("IpcBridgePrivate::", __FUNCTION__, "()")
namespace AkVCam
{
typedef std::shared_ptr<IMoniker> MonikerPtr;
@ -141,7 +135,7 @@ namespace AkVCam
AkVCam::IpcBridge::IpcBridge()
{
AkIpcBridgeLogMethod();
AkLogFunction();
this->d = new IpcBridgePrivate(this);
}
@ -157,7 +151,7 @@ std::wstring AkVCam::IpcBridge::errorMessage() const
void AkVCam::IpcBridge::setOption(const std::string &key, const std::string &value)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (value.empty())
this->d->m_options.erase(key);
@ -167,14 +161,14 @@ void AkVCam::IpcBridge::setOption(const std::string &key, const std::string &val
std::vector<std::wstring> AkVCam::IpcBridge::driverPaths() const
{
AkIpcBridgeLogMethod();
AkLogFunction();
return *this->d->driverPaths();
}
void AkVCam::IpcBridge::setDriverPaths(const std::vector<std::wstring> &driverPaths)
{
AkIpcBridgeLogMethod();
AkLogFunction();
*this->d->driverPaths() = driverPaths;
}
@ -210,21 +204,21 @@ bool AkVCam::IpcBridge::setRootMethod(const std::string &rootMethod)
void AkVCam::IpcBridge::connectService(bool asClient)
{
AkIpcBridgeLogMethod();
AkLogFunction();
this->d->m_asClient = asClient;
this->d->m_mainServer.start();
}
void AkVCam::IpcBridge::disconnectService()
{
AkIpcBridgeLogMethod();
AkLogFunction();
this->d->m_mainServer.stop(true);
this->d->m_asClient = false;
}
bool AkVCam::IpcBridge::registerPeer(bool asClient)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_REQUEST_PORT;
@ -241,10 +235,10 @@ bool AkVCam::IpcBridge::registerPeer(bool asClient)
this->d->m_messageServer.setPipeName(std::wstring(pipeName.begin(),
pipeName.end()));
this->d->m_messageServer.setHandlers(this->d->m_messageHandlers);
AkLoggerLog("Recommended port name: ", portName);
AkLogInfo() << "Recommended port name: " << portName << std::endl;
if (!this->d->m_messageServer.start()) {
AkLoggerLog("Can't start message server");
AkLogError() << "Can't start message server" << std::endl;
return false;
}
@ -260,7 +254,7 @@ bool AkVCam::IpcBridge::registerPeer(bool asClient)
pipeName.c_str(),
(std::min<size_t>)(pipeName.size(), MAX_STRING));
AkLoggerLog("Registering port name: ", portName);
AkLogInfo() << "Registering port name: " << portName << std::endl;
if (!MessageServer::sendMessage(L"\\\\.\\pipe\\" DSHOW_PLUGIN_ASSISTANT_NAME_L,
&message)) {
@ -283,14 +277,14 @@ bool AkVCam::IpcBridge::registerPeer(bool asClient)
portName.end())
+ L".mutex");
this->d->m_portName = portName;
AkLoggerLog("Peer registered as ", portName);
AkLogInfo() << "Peer registered as " << portName << std::endl;
return true;
}
void AkVCam::IpcBridge::unregisterPeer()
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (this->d->m_portName.empty())
return;
@ -311,26 +305,24 @@ void AkVCam::IpcBridge::unregisterPeer()
std::vector<std::string> AkVCam::IpcBridge::listDevices() const
{
AkIpcBridgeLogMethod();
AkLogFunction();
std::vector<std::string> devices;
for (auto camera: this->d->listCameras())
if (this->d->isVirtualCamera(camera))
devices.push_back(this->d->cameraPath(camera));
#ifdef QT_DEBUG
AkLoggerLog("Devices:");
AkLogInfo() << "Devices:" << std::endl;
for (auto &device: devices)
AkLoggerLog(" ", device);
#endif
AkLogInfo() << " " << device << std::endl;
return devices;
}
std::wstring AkVCam::IpcBridge::description(const std::string &deviceId) const
{
AkIpcBridgeLogMethod();
AkLogFunction();
for (auto camera: this->d->listCameras()) {
auto propertyBag = this->d->propertyBag(camera.get());
@ -363,7 +355,7 @@ AkVCam::PixelFormat AkVCam::IpcBridge::defaultOutputPixelFormat() const
std::vector<AkVCam::VideoFormat> AkVCam::IpcBridge::formats(const std::string &deviceId) const
{
AkIpcBridgeLogMethod();
AkLogFunction();
std::vector<AkVCam::VideoFormat> formats;
@ -386,7 +378,7 @@ std::vector<AkVCam::VideoFormat> AkVCam::IpcBridge::formats(const std::string &d
std::string AkVCam::IpcBridge::broadcaster(const std::string &deviceId) const
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_BROADCASTING;
@ -404,15 +396,15 @@ std::string AkVCam::IpcBridge::broadcaster(const std::string &deviceId) const
std::string broadcaster(data->broadcaster);
AkLoggerLog("Device: ", deviceId);
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogInfo() << "Device: " << deviceId << std::endl;
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
return broadcaster;
}
bool AkVCam::IpcBridge::isHorizontalMirrored(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_MIRRORING;
@ -433,7 +425,7 @@ bool AkVCam::IpcBridge::isHorizontalMirrored(const std::string &deviceId)
bool AkVCam::IpcBridge::isVerticalMirrored(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_MIRRORING;
@ -454,7 +446,7 @@ bool AkVCam::IpcBridge::isVerticalMirrored(const std::string &deviceId)
AkVCam::Scaling AkVCam::IpcBridge::scalingMode(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_SCALING;
@ -475,7 +467,7 @@ AkVCam::Scaling AkVCam::IpcBridge::scalingMode(const std::string &deviceId)
AkVCam::AspectRatio AkVCam::IpcBridge::aspectRatioMode(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_ASPECTRATIO;
@ -496,7 +488,7 @@ AkVCam::AspectRatio AkVCam::IpcBridge::aspectRatioMode(const std::string &device
bool AkVCam::IpcBridge::swapRgb(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_SWAPRGB;
@ -517,7 +509,7 @@ bool AkVCam::IpcBridge::swapRgb(const std::string &deviceId)
std::vector<std::string> AkVCam::IpcBridge::listeners(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_LISTENERS;
@ -668,7 +660,7 @@ bool AkVCam::IpcBridge::canApply(AkVCam::IpcBridge::Operation operation) const
std::string AkVCam::IpcBridge::deviceCreate(const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationCreate)) {
this->d->m_error = L"The driver is in use";
@ -898,7 +890,7 @@ bool AkVCam::IpcBridge::deviceEdit(const std::string &deviceId,
const std::wstring &description,
const std::vector<VideoFormat> &formats)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationEdit)) {
this->d->m_error = L"The driver is in use";
@ -1031,7 +1023,7 @@ bool AkVCam::IpcBridge::deviceEdit(const std::string &deviceId,
bool AkVCam::IpcBridge::changeDescription(const std::string &deviceId,
const std::wstring &description)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationEdit)) {
this->d->m_error = L"The driver is in use";
@ -1100,7 +1092,7 @@ bool AkVCam::IpcBridge::changeDescription(const std::string &deviceId,
bool AkVCam::IpcBridge::deviceDestroy(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationDestroy)) {
this->d->m_error = L"The driver is in use";
@ -1212,7 +1204,7 @@ bool AkVCam::IpcBridge::deviceDestroy(const std::string &deviceId)
bool AkVCam::IpcBridge::destroyAllDevices()
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (!this->canApply(OperationDestroyAll)) {
this->d->m_error = L"The driver is in use";
@ -1281,7 +1273,7 @@ bool AkVCam::IpcBridge::deviceStart(const std::string &deviceId,
const VideoFormat &format)
{
UNUSED(format)
AkIpcBridgeLogMethod();
AkLogFunction();
auto it = std::find(this->d->m_broadcasting.begin(),
this->d->m_broadcasting.end(),
deviceId);
@ -1325,7 +1317,7 @@ bool AkVCam::IpcBridge::deviceStart(const std::string &deviceId,
void AkVCam::IpcBridge::deviceStop(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
auto it = std::find(this->d->m_broadcasting.begin(),
this->d->m_broadcasting.end(),
deviceId);
@ -1349,7 +1341,7 @@ void AkVCam::IpcBridge::deviceStop(const std::string &deviceId)
bool AkVCam::IpcBridge::write(const std::string &deviceId,
const VideoFrame &frame)
{
AkIpcBridgeLogMethod();
AkLogFunction();
if (frame.format().size() < 1)
return false;
@ -1399,7 +1391,7 @@ void AkVCam::IpcBridge::setMirroring(const std::string &deviceId,
bool horizontalMirrored,
bool verticalMirrored)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_SETMIRRORING;
@ -1416,7 +1408,7 @@ void AkVCam::IpcBridge::setMirroring(const std::string &deviceId,
void AkVCam::IpcBridge::setScaling(const std::string &deviceId,
Scaling scaling)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_SETSCALING;
@ -1432,7 +1424,7 @@ void AkVCam::IpcBridge::setScaling(const std::string &deviceId,
void AkVCam::IpcBridge::setAspectRatio(const std::string &deviceId,
AspectRatio aspectRatio)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_SETASPECTRATIO;
@ -1447,7 +1439,7 @@ void AkVCam::IpcBridge::setAspectRatio(const std::string &deviceId,
void AkVCam::IpcBridge::setSwapRgb(const std::string &deviceId, bool swap)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_SETSWAPRGB;
@ -1462,7 +1454,7 @@ void AkVCam::IpcBridge::setSwapRgb(const std::string &deviceId, bool swap)
bool AkVCam::IpcBridge::addListener(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_LISTENER_ADD;
@ -1483,7 +1475,7 @@ bool AkVCam::IpcBridge::addListener(const std::string &deviceId)
bool AkVCam::IpcBridge::removeListener(const std::string &deviceId)
{
AkIpcBridgeLogMethod();
AkLogFunction();
Message message;
message.messageId = AKVCAM_ASSISTANT_MSG_DEVICE_LISTENER_REMOVE;
@ -1956,12 +1948,12 @@ std::wstring AkVCam::IpcBridgePrivate::locateDriverPath() const
void AkVCam::IpcBridgePrivate::pipeStateChanged(void *userData,
MessageServer::PipeState state)
{
AkIpcBridgePrivateLogMethod();
AkLogFunction();
auto self = reinterpret_cast<IpcBridgePrivate *>(userData);
switch (state) {
case MessageServer::PipeStateAvailable:
AkLoggerLog("Server Available");
AkLogInfo() << "Server Available" << std::endl;
if (self->self->registerPeer(self->m_asClient)) {
AKVCAM_EMIT(self->self,
@ -1972,7 +1964,7 @@ void AkVCam::IpcBridgePrivate::pipeStateChanged(void *userData,
break;
case MessageServer::PipeStateGone:
AkLoggerLog("Server Gone");
AkLogWarning() << "Server Gone" << std::endl;
AKVCAM_EMIT(self->self,
ServerStateChanged,
IpcBridge::ServerStateGone)

1
dshow/VirtualCamera/VirtualCamera.pro
View file

@ -27,7 +27,6 @@ exists(commons.pri) {
}
include(../dshow.pri)
include(../../VCamUtils/VCamUtils.pri)
CONFIG -= qt
CONFIG += link_prl

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

@ -33,11 +33,6 @@
#include "VCamUtils/src/ipcbridge.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "BaseFilter"
#define AkBaseFilterPrivateLog() \
AkLoggerLog("BaseFilterPrivate::", __FUNCTION__, "()")
#define AkVCamPinCall(pins, func, ...) \
pins->Reset(); \
Pin *pin = nullptr; \
@ -116,7 +111,7 @@ void AkVCam::BaseFilter::addPin(const std::vector<AkVCam::VideoFormat> &formats,
const std::wstring &pinName,
bool changed)
{
AkLogMethod();
AkLogFunction();
this->d->m_pins->addPin(new Pin(this, formats, pinName), changed);
if (this->d->m_pins->count() == 1)
@ -125,24 +120,26 @@ void AkVCam::BaseFilter::addPin(const std::vector<AkVCam::VideoFormat> &formats,
void AkVCam::BaseFilter::removePin(IPin *pin, bool changed)
{
AkLogMethod();
AkLogFunction();
this->d->m_ipcBridge.disconnectService();
this->d->m_pins->removePin(pin, changed);
}
AkVCam::BaseFilter *AkVCam::BaseFilter::create(const GUID &clsid)
{
AkLoggerLog("BaseFilter::create()");
AkLogFunction();
auto camera = cameraFromId(clsid);
AkLoggerLog("CLSID: ", stringFromClsid(clsid));
AkLoggerLog("ID: ", camera);
AkLogInfo() << "CLSID: " << stringFromClsid(clsid) << std::endl;
AkLogInfo() << "ID: " << camera << std::endl;
if (camera < 0)
return nullptr;
auto description = cameraDescription(DWORD(camera));
AkLoggerLog("Description: ", std::string(description.begin(),
description.end()));
AkLogInfo() << "Description: "
<< std::string(description.begin(),
description.end())
<< std::endl;
auto baseFilter = new BaseFilter(clsid,
description,
DSHOW_PLUGIN_VENDOR_L);
@ -164,8 +161,8 @@ IReferenceClock *AkVCam::BaseFilter::referenceClock() const
HRESULT AkVCam::BaseFilter::QueryInterface(const IID &riid, void **ppvObject)
{
AkLogMethod();
AkLoggerLog("IID: ", AkVCam::stringFromClsid(riid));
AkLogFunction();
AkLogInfo() << "IID: " << AkVCam::stringFromClsid(riid) << std::endl;
if (!ppvObject)
return E_POINTER;
@ -238,7 +235,7 @@ HRESULT AkVCam::BaseFilter::QueryInterface(const IID &riid, void **ppvObject)
HRESULT AkVCam::BaseFilter::EnumPins(IEnumPins **ppEnum)
{
AkLogMethod();
AkLogFunction();
if (!this->d->m_pins)
return E_FAIL;
@ -253,7 +250,7 @@ HRESULT AkVCam::BaseFilter::EnumPins(IEnumPins **ppEnum)
HRESULT AkVCam::BaseFilter::FindPin(LPCWSTR Id, IPin **ppPin)
{
AkLogMethod();
AkLogFunction();
if (!ppPin)
return E_POINTER;
@ -290,7 +287,7 @@ HRESULT AkVCam::BaseFilter::FindPin(LPCWSTR Id, IPin **ppPin)
HRESULT AkVCam::BaseFilter::QueryFilterInfo(FILTER_INFO *pInfo)
{
AkLogMethod();
AkLogFunction();
if (!pInfo)
return E_POINTER;
@ -314,21 +311,23 @@ HRESULT AkVCam::BaseFilter::QueryFilterInfo(FILTER_INFO *pInfo)
HRESULT AkVCam::BaseFilter::JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName)
{
AkLogMethod();
AkLogFunction();
this->d->m_filterGraph = pGraph;
this->d->m_filterName = std::wstring(pName? pName: L"");
AkLoggerLog("Filter graph: ", this->d->m_filterGraph);
AkLoggerLog("Name: ", std::string(this->d->m_filterName.begin(),
this->d->m_filterName.end()));
AkLogInfo() << "Filter graph: " << this->d->m_filterGraph << std::endl;
AkLogInfo() << "Name: "
<< std::string(this->d->m_filterName.begin(),
this->d->m_filterName.end())
<< std::endl;
return S_OK;
}
HRESULT AkVCam::BaseFilter::QueryVendorInfo(LPWSTR *pVendorInfo)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_vendor.size() < 1)
return E_NOTIMPL;
@ -396,7 +395,7 @@ AkVCam::BaseFilterPrivate::~BaseFilterPrivate()
IEnumPins *AkVCam::BaseFilterPrivate::pinsForDevice(const std::string &deviceId)
{
AkLogMethod();
AkLogFunction();
CLSID clsid;
self->GetClassID(&clsid);
@ -450,7 +449,7 @@ void AkVCam::BaseFilterPrivate::updatePins()
void AkVCam::BaseFilterPrivate::serverStateChanged(void *userData,
IpcBridge::ServerState state)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
IEnumPins *pins = nullptr;
self->self->EnumPins(&pins);
@ -468,7 +467,7 @@ void AkVCam::BaseFilterPrivate::frameReady(void *userData,
const std::string &deviceId,
const VideoFrame &frame)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
AkVCamDevicePinCall(deviceId, self, frameReady, frame);
}
@ -477,7 +476,7 @@ void AkVCam::BaseFilterPrivate::setBroadcasting(void *userData,
const std::string &deviceId,
const std::string &broadcaster)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
AkVCamDevicePinCall(deviceId, self, setBroadcasting, broadcaster);
}
@ -487,7 +486,7 @@ void AkVCam::BaseFilterPrivate::setMirror(void *userData,
bool horizontalMirror,
bool verticalMirror)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
AkVCamDevicePinCall(deviceId,
self,
@ -500,7 +499,7 @@ void AkVCam::BaseFilterPrivate::setScaling(void *userData,
const std::string &deviceId,
Scaling scaling)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
AkVCamDevicePinCall(deviceId, self, setScaling, scaling);
}
@ -509,7 +508,7 @@ void AkVCam::BaseFilterPrivate::setAspectRatio(void *userData,
const std::string &deviceId,
AspectRatio aspectRatio)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
AkVCamDevicePinCall(deviceId, self, setAspectRatio, aspectRatio);
}
@ -518,7 +517,7 @@ void AkVCam::BaseFilterPrivate::setSwapRgb(void *userData,
const std::string &deviceId,
bool swap)
{
AkBaseFilterPrivateLog();
AkLogFunction();
auto self = reinterpret_cast<BaseFilterPrivate *>(userData);
AkVCamDevicePinCall(deviceId, self, setSwapRgb, swap);
}

14
dshow/VirtualCamera/src/classfactory.cpp
View file

@ -23,8 +23,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "ClassFactory"
namespace AkVCam
{
class ClassFactoryPrivate
@ -56,8 +54,8 @@ bool AkVCam::ClassFactory::locked()
HRESULT AkVCam::ClassFactory::QueryInterface(const IID &riid, void **ppvObject)
{
AkLogMethod();
AkLoggerLog("IID: ", AkVCam::stringFromClsid(riid));
AkLogFunction();
AkLogInfo() << "IID: " << AkVCam::stringFromClsid(riid) << std::endl;
if (!ppvObject)
return E_POINTER;
@ -94,9 +92,9 @@ HRESULT AkVCam::ClassFactory::CreateInstance(IUnknown *pUnkOuter,
const IID &riid,
void **ppvObject)
{
AkLogMethod();
AkLoggerLog("Outer: ", ULONG_PTR(pUnkOuter));
AkLoggerLog("IID: ", stringFromClsid(riid));
AkLogFunction();
AkLogInfo() << "Outer: " << ULONG_PTR(pUnkOuter) << std::endl;
AkLogInfo() << "IID: " << stringFromClsid(riid) << std::endl;
if (!ppvObject)
return E_INVALIDARG;
@ -114,7 +112,7 @@ HRESULT AkVCam::ClassFactory::CreateInstance(IUnknown *pUnkOuter,
HRESULT AkVCam::ClassFactory::LockServer(BOOL fLock)
{
AkLogMethod();
AkLogFunction();
this->d->m_locked += fLock? 1: -1;
return S_OK;

34
dshow/VirtualCamera/src/cunknown.cpp
View file

@ -24,18 +24,24 @@
#include "VCamUtils/src/utils.h"
#define AkCUnknownLogMethod() \
AkLoggerLog((this->d->m_parent? \
stringFromClsid(this->d->m_parentCLSID): \
std::string("CUnknown")), \
"(", (this->d->m_parent? this->d->m_parent: this), \
")::", __FUNCTION__, "()")
AkLogFunction() << " " \
<< (this->d->m_parent? \
stringFromClsid(this->d->m_parentCLSID): \
std::string("CUnknown")) \
<< "(" \
<< (this->d->m_parent? this->d->m_parent: this) \
<< ")" \
<< std::endl
#define AkCUnknownLogThis() \
AkLoggerLog("Returning ", \
(this->d->m_parent? \
stringFromClsid(this->d->m_parentCLSID): \
std::string("CUnknown")), \
"(", (this->d->m_parent? this->d->m_parent: this), ")")
AkLogInfo() << "Returning " \
<< (this->d->m_parent? \
stringFromClsid(this->d->m_parentCLSID): \
std::string("CUnknown")) \
<< "(" \
<< (this->d->m_parent? this->d->m_parent: this) \
<< ")" \
<< std::endl
namespace AkVCam
{
@ -76,7 +82,7 @@ ULONG AkVCam::CUnknown::ref() const
HRESULT AkVCam::CUnknown::QueryInterface(const IID &riid, void **ppvObject)
{
AkCUnknownLogMethod();
AkLoggerLog("IID: ", AkVCam::stringFromClsid(riid));
AkLogInfo() << "IID: " << AkVCam::stringFromClsid(riid) << std::endl;
if (!ppvObject)
return E_POINTER;
@ -91,7 +97,7 @@ HRESULT AkVCam::CUnknown::QueryInterface(const IID &riid, void **ppvObject)
return S_OK;
} else {
AkLoggerLog("Unknown interface");
AkLogWarning() << "Unknown interface" << std::endl;
}
return E_NOINTERFACE;
@ -101,7 +107,7 @@ ULONG AkVCam::CUnknown::AddRef()
{
AkCUnknownLogMethod();
this->d->m_ref++;
AkLoggerLog("REF: ", this->d->m_ref);
AkLogInfo() << "REF: " << this->d->m_ref << std::endl;
return this->d->m_ref;
}
@ -109,7 +115,7 @@ ULONG AkVCam::CUnknown::AddRef()
ULONG AkVCam::CUnknown::Release()
{
AkCUnknownLogMethod();
AkLoggerLog("REF: ", this->d->m_ref);
AkLogInfo() << "REF: " << this->d->m_ref << std::endl;
if (this->d->m_ref)
this->d->m_ref--;

12
dshow/VirtualCamera/src/enummediatypes.cpp
View file

@ -24,8 +24,6 @@
#include "VCamUtils/src/image/videoformat.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "EnumMediaTypes"
namespace AkVCam
{
class EnumMediaTypesPrivate
@ -95,7 +93,7 @@ HRESULT AkVCam::EnumMediaTypes::Next(ULONG cMediaTypes,
AM_MEDIA_TYPE **ppMediaTypes,
ULONG *pcFetched)
{
AkLogMethod();
AkLogFunction();
if (pcFetched)
*pcFetched = 0;
@ -134,8 +132,8 @@ HRESULT AkVCam::EnumMediaTypes::Next(ULONG cMediaTypes,
HRESULT AkVCam::EnumMediaTypes::Skip(ULONG cMediaTypes)
{
AkLogMethod();
AkLoggerLog("Skip ", cMediaTypes, " media types");
AkLogFunction();
AkLogInfo() << "Skip " << cMediaTypes << " media types" << std::endl;
if (this->d->m_changed) {
this->d->m_changed = false;
@ -155,7 +153,7 @@ HRESULT AkVCam::EnumMediaTypes::Skip(ULONG cMediaTypes)
HRESULT AkVCam::EnumMediaTypes::Reset()
{
AkLogMethod();
AkLogFunction();
this->d->m_position = 0;
return S_OK;
@ -163,7 +161,7 @@ HRESULT AkVCam::EnumMediaTypes::Reset()
HRESULT AkVCam::EnumMediaTypes::Clone(IEnumMediaTypes **ppEnum)
{
AkLogMethod();
AkLogFunction();
if (!ppEnum)
return E_POINTER;

12
dshow/VirtualCamera/src/enumpins.cpp
View file

@ -25,8 +25,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "EnumPins"
namespace AkVCam
{
class EnumPinsPrivate
@ -99,7 +97,7 @@ void AkVCam::EnumPins::setBaseFilter(BaseFilter *baseFilter)
HRESULT AkVCam::EnumPins::Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched)
{
AkLogMethod();
AkLogFunction();
if (pcFetched)
*pcFetched = 0;
@ -139,8 +137,8 @@ HRESULT AkVCam::EnumPins::Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched)
HRESULT AkVCam::EnumPins::Skip(ULONG cPins)
{
AkLogMethod();
AkLoggerLog("Skip ", cPins, " pins");
AkLogFunction();
AkLogInfo() << "Skip " << cPins << " pins" << std::endl;
if (this->d->m_changed) {
this->d->m_changed = false;
@ -160,7 +158,7 @@ HRESULT AkVCam::EnumPins::Skip(ULONG cPins)
HRESULT AkVCam::EnumPins::Reset()
{
AkLogMethod();
AkLogFunction();
this->d->m_position = 0;
return S_OK;
@ -168,7 +166,7 @@ HRESULT AkVCam::EnumPins::Reset()
HRESULT AkVCam::EnumPins::Clone(IEnumPins **ppEnum)
{
AkLogMethod();
AkLogFunction();
if (!ppEnum)
return E_POINTER;

4
dshow/VirtualCamera/src/filtermiscflags.cpp
View file

@ -21,8 +21,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "FilterMiscFlags"
AkVCam::FilterMiscFlags::FilterMiscFlags():
CUnknown(this, IID_IAMFilterMiscFlags)
{
@ -36,7 +34,7 @@ AkVCam::FilterMiscFlags::~FilterMiscFlags()
ULONG AkVCam::FilterMiscFlags::GetMiscFlags()
{
AkLogMethod();
AkLogFunction();
return AM_FILTER_MISC_FLAGS_IS_SOURCE;
}

4
dshow/VirtualCamera/src/latency.cpp
View file

@ -26,8 +26,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "Latency"
namespace AkVCam
{
class LatencyPrivate
@ -51,7 +49,7 @@ AkVCam::Latency::~Latency()
HRESULT AkVCam::Latency::GetLatency(REFERENCE_TIME *prtLatency)
{
AkLogMethod();
AkLogFunction();
if (!prtLatency)
return E_POINTER;

20
dshow/VirtualCamera/src/mediafilter.cpp
View file

@ -24,8 +24,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "MediaFilter"
namespace AkVCam
{
typedef std::pair<void *, StateChangedCallbackT> StateChangedCallback;
@ -64,14 +62,14 @@ AkVCam::MediaFilter::~MediaFilter()
void AkVCam::MediaFilter::connectStateChanged(void *userData,
StateChangedCallbackT callback)
{
AkLogMethod();
AkLogFunction();
this->d->m_stateChanged.push_back({userData, callback});
}
void AkVCam::MediaFilter::disconnectStateChanged(void *userData,
StateChangedCallbackT callback)
{
AkLogMethod();
AkLogFunction();
for (auto it = this->d->m_stateChanged.begin();
it != this->d->m_stateChanged.end();
@ -87,7 +85,7 @@ void AkVCam::MediaFilter::disconnectStateChanged(void *userData,
HRESULT AkVCam::MediaFilter::Stop()
{
AkLogMethod();
AkLogFunction();
this->d->m_state = State_Stopped;
HRESULT result = S_OK;
@ -105,7 +103,7 @@ HRESULT AkVCam::MediaFilter::Stop()
HRESULT AkVCam::MediaFilter::Pause()
{
AkLogMethod();
AkLogFunction();
this->d->m_state = State_Paused;
HRESULT result = S_OK;
@ -123,7 +121,7 @@ HRESULT AkVCam::MediaFilter::Pause()
HRESULT AkVCam::MediaFilter::Run(REFERENCE_TIME tStart)
{
AkLogMethod();
AkLogFunction();
this->d->m_start = tStart;
this->d->m_state = State_Running;
HRESULT result = S_OK;
@ -144,20 +142,20 @@ HRESULT AkVCam::MediaFilter::GetState(DWORD dwMilliSecsTimeout,
FILTER_STATE *State)
{
UNUSED(dwMilliSecsTimeout)
AkLogMethod();
AkLogFunction();
if (!State)
return E_POINTER;
*State = this->d->m_state;
AkLoggerLog("State: ", *State);
AkLogInfo() << "State: " << *State << std::endl;
return S_OK;
}
HRESULT AkVCam::MediaFilter::SetSyncSource(IReferenceClock *pClock)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_clock)
this->d->m_clock->Release();
@ -172,7 +170,7 @@ HRESULT AkVCam::MediaFilter::SetSyncSource(IReferenceClock *pClock)
HRESULT AkVCam::MediaFilter::GetSyncSource(IReferenceClock **pClock)
{
AkLogMethod();
AkLogFunction();
if (!pClock)
return E_POINTER;

34
dshow/VirtualCamera/src/mediasample.cpp
View file

@ -23,8 +23,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "MediaSample"
namespace AkVCam
{
class MediaSamplePrivate
@ -91,7 +89,7 @@ ULONG AkVCam::MediaSample::Release()
HRESULT AkVCam::MediaSample::GetPointer(BYTE **ppBuffer)
{
AkLogMethod();
AkLogFunction();
if (!ppBuffer)
return E_POINTER;
@ -103,7 +101,7 @@ HRESULT AkVCam::MediaSample::GetPointer(BYTE **ppBuffer)
LONG AkVCam::MediaSample::GetSize()
{
AkLogMethod();
AkLogFunction();
return this->d->m_bufferSize;
}
@ -111,7 +109,7 @@ LONG AkVCam::MediaSample::GetSize()
HRESULT AkVCam::MediaSample::GetTime(REFERENCE_TIME *pTimeStart,
REFERENCE_TIME *pTimeEnd)
{
AkLogMethod();
AkLogFunction();
if (!pTimeStart || !pTimeEnd)
return E_POINTER;
@ -134,7 +132,7 @@ HRESULT AkVCam::MediaSample::GetTime(REFERENCE_TIME *pTimeStart,
HRESULT AkVCam::MediaSample::SetTime(REFERENCE_TIME *pTimeStart,
REFERENCE_TIME *pTimeEnd)
{
AkLogMethod();
AkLogFunction();
this->d->m_sampleTimeStart = pTimeStart? *pTimeStart: -1;
this->d->m_sampleTimeEnd = pTimeEnd? *pTimeEnd: -1;
@ -144,14 +142,14 @@ HRESULT AkVCam::MediaSample::SetTime(REFERENCE_TIME *pTimeStart,
HRESULT AkVCam::MediaSample::IsSyncPoint()
{
AkLogMethod();
AkLogFunction();
return this->d->m_syncPoint? S_OK: S_FALSE;
}
HRESULT AkVCam::MediaSample::SetSyncPoint(BOOL bIsSyncPoint)
{
AkLogMethod();
AkLogFunction();
this->d->m_syncPoint = bIsSyncPoint;
return S_OK;
@ -159,14 +157,14 @@ HRESULT AkVCam::MediaSample::SetSyncPoint(BOOL bIsSyncPoint)
HRESULT AkVCam::MediaSample::IsPreroll()
{
AkLogMethod();
AkLogFunction();
return this->d->m_preroll? S_OK: S_FALSE;
}
HRESULT AkVCam::MediaSample::SetPreroll(BOOL bIsPreroll)
{
AkLogMethod();
AkLogFunction();
this->d->m_preroll = bIsPreroll;
return S_OK;
@ -174,14 +172,14 @@ HRESULT AkVCam::MediaSample::SetPreroll(BOOL bIsPreroll)
LONG AkVCam::MediaSample::GetActualDataLength()
{
AkLogMethod();
AkLogFunction();
return this->d->m_dataLength;
}
HRESULT AkVCam::MediaSample::SetActualDataLength(LONG lLen)
{
AkLogMethod();
AkLogFunction();
if (lLen < 0 || lLen > this->d->m_bufferSize)
return VFW_E_BUFFER_OVERFLOW;
@ -193,7 +191,7 @@ HRESULT AkVCam::MediaSample::SetActualDataLength(LONG lLen)
HRESULT AkVCam::MediaSample::GetMediaType(AM_MEDIA_TYPE **ppMediaType)
{
AkLogMethod();
AkLogFunction();
if (!ppMediaType)
return E_POINTER;
@ -213,7 +211,7 @@ HRESULT AkVCam::MediaSample::GetMediaType(AM_MEDIA_TYPE **ppMediaType)
HRESULT AkVCam::MediaSample::SetMediaType(AM_MEDIA_TYPE *pMediaType)
{
AkLogMethod();
AkLogFunction();
if (!pMediaType)
return E_POINTER;
@ -233,14 +231,14 @@ HRESULT AkVCam::MediaSample::SetMediaType(AM_MEDIA_TYPE *pMediaType)
HRESULT AkVCam::MediaSample::IsDiscontinuity()
{
AkLogMethod();
AkLogFunction();
return this->d->m_discontinuity? S_OK: S_FALSE;
}
HRESULT AkVCam::MediaSample::SetDiscontinuity(BOOL bDiscontinuity)
{
AkLogMethod();
AkLogFunction();
this->d->m_discontinuity = bDiscontinuity;
return S_OK;
@ -249,7 +247,7 @@ HRESULT AkVCam::MediaSample::SetDiscontinuity(BOOL bDiscontinuity)
HRESULT AkVCam::MediaSample::GetMediaTime(LONGLONG *pTimeStart,
LONGLONG *pTimeEnd)
{
AkLogMethod();
AkLogFunction();
if (!pTimeStart || !pTimeEnd)
return E_POINTER;
@ -266,7 +264,7 @@ HRESULT AkVCam::MediaSample::GetMediaTime(LONGLONG *pTimeStart,
HRESULT AkVCam::MediaSample::SetMediaTime(LONGLONG *pTimeStart,
LONGLONG *pTimeEnd)
{
AkLogMethod();
AkLogFunction();
this->d->m_mediaTimeStart = pTimeStart? *pTimeStart: -1;
this->d->m_mediaTimeEnd = pTimeEnd? *pTimeEnd: -1;

6
dshow/VirtualCamera/src/mediasample2.cpp
View file

@ -21,8 +21,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "MediaFilter2"
namespace AkVCam
{
class MediaSample2Private
@ -60,7 +58,7 @@ AkVCam::MediaSample2::~MediaSample2()
HRESULT AkVCam::MediaSample2::SetProperties(DWORD cbProperties,
const BYTE *pbProperties)
{
AkLogMethod();
AkLogFunction();
if (cbProperties < sizeof(AM_SAMPLE2_PROPERTIES))
return E_INVALIDARG;
@ -96,7 +94,7 @@ HRESULT AkVCam::MediaSample2::SetProperties(DWORD cbProperties,
HRESULT AkVCam::MediaSample2::GetProperties(DWORD cbProperties,
BYTE *pbProperties)
{
AkLogMethod();
AkLogFunction();
if (cbProperties < sizeof(AM_SAMPLE2_PROPERTIES))
return E_INVALIDARG;

26
dshow/VirtualCamera/src/memallocator.cpp
View file

@ -28,8 +28,6 @@
#include "VCamUtils/src/image/videoformat.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "MemAllocator"
namespace AkVCam
{
class MemAllocatorPrivate
@ -64,7 +62,7 @@ AkVCam::MemAllocator::~MemAllocator()
HRESULT AkVCam::MemAllocator::SetProperties(ALLOCATOR_PROPERTIES *pRequest,
ALLOCATOR_PROPERTIES *pActual)
{
AkLogMethod();
AkLogFunction();
if (!pRequest || !pActual)
return E_POINTER;
@ -87,7 +85,7 @@ HRESULT AkVCam::MemAllocator::SetProperties(ALLOCATOR_PROPERTIES *pRequest,
HRESULT AkVCam::MemAllocator::GetProperties(ALLOCATOR_PROPERTIES *pProps)
{
AkLogMethod();
AkLogFunction();
if (!pProps)
return E_POINTER;
@ -100,14 +98,14 @@ HRESULT AkVCam::MemAllocator::GetProperties(ALLOCATOR_PROPERTIES *pProps)
HRESULT AkVCam::MemAllocator::Commit()
{
AkLogMethod();
AkLogFunction();
if (this->d->m_commited)
return S_OK;
if (this->d->m_properties.cBuffers < 1
|| this->d->m_properties.cbBuffer < 1) {
AkLoggerLog("Wrong memory allocator size");
AkLogError() << "Wrong memory allocator size" << std::endl;
return VFW_E_SIZENOTSET;
}
@ -131,7 +129,7 @@ HRESULT AkVCam::MemAllocator::Commit()
HRESULT AkVCam::MemAllocator::Decommit()
{
AkLogMethod();
AkLogFunction();
if (!this->d->m_commited)
return S_OK;
@ -151,10 +149,14 @@ HRESULT AkVCam::MemAllocator::Decommit()
freeSamples++;
}
AkLoggerLog("Free samples: ", freeSamples, "/", totalSamples);
AkLogInfo() << "Free samples: "
<< freeSamples
<< "/"
<< totalSamples
<< std::endl;
if (freeSamples >= totalSamples) {
AkLoggerLog("Decommiting");
AkLogInfo() << "Decommiting" << std::endl;
this->d->m_samples.clear();
this->d->m_commited = false;
this->d->m_decommiting = false;
@ -168,7 +170,7 @@ HRESULT AkVCam::MemAllocator::GetBuffer(IMediaSample **ppBuffer,
REFERENCE_TIME *pEndTime,
DWORD dwFlags)
{
AkLogMethod();
AkLogFunction();
if (!ppBuffer)
return E_POINTER;
@ -182,7 +184,7 @@ HRESULT AkVCam::MemAllocator::GetBuffer(IMediaSample **ppBuffer,
*pEndTime = 0;
if (!this->d->m_commited || this->d->m_decommiting) {
AkLoggerLog("Allocator not commited.");
AkLogError() << "Allocator not commited." << std::endl;
return VFW_E_NOT_COMMITTED;
}
@ -219,7 +221,7 @@ HRESULT AkVCam::MemAllocator::GetBuffer(IMediaSample **ppBuffer,
HRESULT AkVCam::MemAllocator::ReleaseBuffer(IMediaSample *pBuffer)
{
UNUSED(pBuffer)
AkLogMethod();
AkLogFunction();
this->d->m_mutex.lock();
this->d->m_bufferReleased.notify_one();

4
dshow/VirtualCamera/src/persist.cpp
View file

@ -21,8 +21,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "Persist"
namespace AkVCam
{
class PersistPrivate
@ -46,7 +44,7 @@ AkVCam::Persist::~Persist()
HRESULT AkVCam::Persist::GetClassID(CLSID *pClassID)
{
AkLogMethod();
AkLogFunction();
if (!pClassID)
return E_POINTER;

12
dshow/VirtualCamera/src/persistpropertybag.cpp
View file

@ -22,8 +22,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "PersistPropertyBag"
namespace AkVCam
{
class PersistPropertyBagPrivate
@ -50,8 +48,8 @@ AkVCam::PersistPropertyBag::~PersistPropertyBag()
HRESULT AkVCam::PersistPropertyBag::QueryInterface(const IID &riid,
void **ppvObject)
{
AkLogMethod();
AkLoggerLog("IID: ", AkVCam::stringFromClsid(riid));
AkLogFunction();
AkLogInfo() << "IID: " << AkVCam::stringFromClsid(riid) << std::endl;
if (!ppvObject)
return E_POINTER;
@ -89,7 +87,7 @@ HRESULT AkVCam::PersistPropertyBag::QueryInterface(const IID &riid,
HRESULT AkVCam::PersistPropertyBag::InitNew()
{
AkLogMethod();
AkLogFunction();
return S_OK;
}
@ -98,7 +96,7 @@ HRESULT AkVCam::PersistPropertyBag::Load(IPropertyBag *pPropBag,
IErrorLog *pErrorLog)
{
UNUSED(pErrorLog)
AkLogMethod();
AkLogFunction();
if (!pPropBag)
return E_POINTER;
@ -122,7 +120,7 @@ HRESULT AkVCam::PersistPropertyBag::Save(IPropertyBag *pPropBag,
{
UNUSED(fClearDirty)
UNUSED(fSaveAllProperties)
AkLogMethod();
AkLogFunction();
if (!pPropBag)
return E_POINTER;

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

@ -41,8 +41,6 @@
#include "VCamUtils/src/image/videoframe.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "Pin"
namespace AkVCam
{
class PinPrivate
@ -185,23 +183,23 @@ AkVCam::Pin::~Pin()
AkVCam::BaseFilter *AkVCam::Pin::baseFilter() const
{
AkLogMethod();
AkLogFunction();
return this->d->m_baseFilter;
}
void AkVCam::Pin::setBaseFilter(BaseFilter *baseFilter)
{
AkLogMethod();
AkLogFunction();
this->d->m_baseFilter = baseFilter;
}
HRESULT AkVCam::Pin::stateChanged(void *userData, FILTER_STATE state)
{
auto self = reinterpret_cast<Pin *>(userData);
AkLoggerLog(AK_CUR_INTERFACE, "(", self, ")::", __FUNCTION__, "()");
AkLoggerLog("Old state: ", self->d->m_prevState);
AkLoggerLog("New state: ", state);
AkLogFunction();
AkLogInfo() << "Old state: " << self->d->m_prevState << std::endl;
AkLogInfo() << "New state: " << state << std::endl;
if (state == self->d->m_prevState)
return S_OK;
@ -221,7 +219,9 @@ HRESULT AkVCam::Pin::stateChanged(void *userData, FILTER_STATE state)
self->d->m_running = true;
self->d->m_sendFrameThread =
std::thread(&PinPrivate::sendFrameLoop, self->d);
AkLoggerLog("Launching thread ", self->d->m_sendFrameThread.get_id());
AkLogInfo() << "Launching thread "
<< self->d->m_sendFrameThread.get_id()
<< std::endl;
auto clock = self->d->m_baseFilter->referenceClock();
REFERENCE_TIME now = 0;
@ -260,7 +260,7 @@ HRESULT AkVCam::Pin::stateChanged(void *userData, FILTER_STATE state)
void AkVCam::Pin::serverStateChanged(IpcBridge::ServerState state)
{
AkLogMethod();
AkLogFunction();
if (state == IpcBridge::ServerStateGone) {
this->d->m_broadcaster.clear();
@ -279,9 +279,9 @@ void AkVCam::Pin::serverStateChanged(IpcBridge::ServerState state)
void AkVCam::Pin::frameReady(const VideoFrame &frame)
{
AkLogMethod();
AkLoggerLog("Running: ", this->d->m_running);
AkLoggerLog("Broadcaster: ", this->d->m_broadcaster);
AkLogFunction();
AkLogInfo() << "Running: " << this->d->m_running << std::endl;
AkLogInfo() << "Broadcaster: " << this->d->m_broadcaster << std::endl;
if (!this->d->m_running)
return;
@ -300,8 +300,8 @@ void AkVCam::Pin::frameReady(const VideoFrame &frame)
void AkVCam::Pin::setBroadcasting(const std::string &broadcaster)
{
AkLogMethod();
AkLoggerLog("Broadcaster: ", broadcaster);
AkLogFunction();
AkLogInfo() << "Broadcaster: " << broadcaster << std::endl;
if (this->d->m_broadcaster == broadcaster)
return;
@ -317,7 +317,7 @@ void AkVCam::Pin::setBroadcasting(const std::string &broadcaster)
void AkVCam::Pin::setMirror(bool horizontalMirror, bool verticalMirror)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_horizontalMirror == horizontalMirror
&& this->d->m_verticalMirror == verticalMirror)
@ -330,7 +330,7 @@ void AkVCam::Pin::setMirror(bool horizontalMirror, bool verticalMirror)
void AkVCam::Pin::setScaling(Scaling scaling)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_scaling == scaling)
return;
@ -341,7 +341,7 @@ void AkVCam::Pin::setScaling(Scaling scaling)
void AkVCam::Pin::setAspectRatio(AspectRatio aspectRatio)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_aspectRatio == aspectRatio)
return;
@ -352,7 +352,7 @@ void AkVCam::Pin::setAspectRatio(AspectRatio aspectRatio)
void AkVCam::Pin::setSwapRgb(bool swap)
{
AkLogMethod();
AkLogFunction();
if (this->d->m_swapRgb == swap)
return;
@ -383,8 +383,8 @@ void AkVCam::Pin::setVerticalFlip(bool flip)
HRESULT AkVCam::Pin::QueryInterface(const IID &riid, void **ppvObject)
{
AkLogMethod();
AkLoggerLog("IID: ", AkVCam::stringFromClsid(riid));
AkLogFunction();
AkLogInfo() << "IID: " << AkVCam::stringFromClsid(riid) << std::endl;
if (!ppvObject)
return E_POINTER;
@ -433,9 +433,9 @@ HRESULT AkVCam::Pin::QueryInterface(const IID &riid, void **ppvObject)
HRESULT AkVCam::Pin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
{
AkLogMethod();
AkLoggerLog("Receive pin: ", pReceivePin);
AkLoggerLog("Media type: ", stringFromMediaType(pmt));
AkLogFunction();
AkLogInfo() << "Receive pin: " << pReceivePin << std::endl;
AkLogInfo() << "Media type: " << stringFromMediaType(pmt) << std::endl;
if (!pReceivePin)
return E_POINTER;
@ -496,7 +496,9 @@ HRESULT AkVCam::Pin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
mediaTypes->Reset();
while (mediaTypes->Next(1, &mt, nullptr) == S_OK) {
AkLoggerLog("Testing media type: ", stringFromMediaType(mt));
AkLogInfo() << "Testing media type: "
<< stringFromMediaType(mt)
<< std::endl;
// If the mediatype match our suported mediatypes...
if (this->QueryAccept(mt) == S_OK) {
@ -535,7 +537,9 @@ HRESULT AkVCam::Pin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
if (!mediaType)
return VFW_E_NO_ACCEPTABLE_TYPES;
AkLoggerLog("Setting Media Type: ", stringFromMediaType(mediaType));
AkLogInfo() << "Setting Media Type: "
<< stringFromMediaType(mediaType)
<< std::endl;
auto result = pReceivePin->ReceiveConnection(this, mediaType);
if (FAILED(result)) {
@ -544,7 +548,7 @@ HRESULT AkVCam::Pin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
return result;
}
AkLoggerLog("Connection accepted by input pin");
AkLogInfo() << "Connection accepted by input pin" << std::endl;
// Define memory allocator requirements.
ALLOCATOR_PROPERTIES allocatorRequirements;
@ -606,7 +610,7 @@ HRESULT AkVCam::Pin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
this->d->m_connectedTo = pReceivePin;
this->d->m_connectedTo->AddRef();
this->d->m_baseFilter->connectStateChanged(this, &Pin::stateChanged);
AkLoggerLog("Connected to ", pReceivePin);
AkLogInfo() << "Connected to " << pReceivePin << std::endl;
return S_OK;
}
@ -616,14 +620,14 @@ HRESULT AkVCam::Pin::ReceiveConnection(IPin *pConnector,
{
UNUSED(pConnector)
UNUSED(pmt)
AkLogMethod();
AkLogFunction();
return VFW_E_TYPE_NOT_ACCEPTED;
}
HRESULT AkVCam::Pin::Disconnect()
{
AkLogMethod();
AkLogFunction();
this->d->m_baseFilter->disconnectStateChanged(this, &Pin::stateChanged);
if (this->d->m_baseFilter) {
@ -654,7 +658,7 @@ HRESULT AkVCam::Pin::Disconnect()
HRESULT AkVCam::Pin::ConnectedTo(IPin **pPin)
{
AkLogMethod();
AkLogFunction();
if (!pPin)
return E_POINTER;
@ -672,7 +676,7 @@ HRESULT AkVCam::Pin::ConnectedTo(IPin **pPin)
HRESULT AkVCam::Pin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
{
AkLogMethod();
AkLogFunction();
if (!pmt)
return E_POINTER;
@ -685,14 +689,16 @@ HRESULT AkVCam::Pin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
AM_MEDIA_TYPE *mediaType = nullptr;
this->GetFormat(&mediaType);
copyMediaType(pmt, mediaType);
AkLoggerLog("Media Type: ", stringFromMediaType(mediaType));
AkLogInfo() << "Media Type: "
<< stringFromMediaType(mediaType)
<< std::endl;
return S_OK;
}
HRESULT AkVCam::Pin::QueryPinInfo(PIN_INFO *pInfo)
{
AkLogMethod();
AkLogFunction();
if (!pInfo)
return E_POINTER;
@ -716,7 +722,7 @@ HRESULT AkVCam::Pin::QueryPinInfo(PIN_INFO *pInfo)
HRESULT AkVCam::Pin::QueryDirection(PIN_DIRECTION *pPinDir)
{
AkLogMethod();
AkLogFunction();
if (!pPinDir)
return E_POINTER;
@ -728,7 +734,7 @@ HRESULT AkVCam::Pin::QueryDirection(PIN_DIRECTION *pPinDir)
HRESULT AkVCam::Pin::QueryId(LPWSTR *Id)
{
AkLogMethod();
AkLogFunction();
if (!Id)
return E_POINTER;
@ -749,27 +755,27 @@ HRESULT AkVCam::Pin::QueryId(LPWSTR *Id)
HRESULT AkVCam::Pin::QueryAccept(const AM_MEDIA_TYPE *pmt)
{
AkLogMethod();
AkLogFunction();
if (!pmt)
return E_POINTER;
AkLoggerLog("Accept? ", stringFromMediaType(pmt));
AkLogInfo() << "Accept? " << stringFromMediaType(pmt) << std::endl;
if (!containsMediaType(pmt, this->d->m_mediaTypes)) {
AkLoggerLog("NO");
AkLogInfo() << "NO" << std::endl;
return S_FALSE;
}
AkLoggerLog("YES");
AkLogInfo() << "YES" << std::endl;
return S_OK;
}
HRESULT AkVCam::Pin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
{
AkLogMethod();
AkLogFunction();
if (!ppEnum)
return E_POINTER;
@ -782,7 +788,7 @@ HRESULT AkVCam::Pin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
HRESULT AkVCam::Pin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
{
AkLogMethod();
AkLogFunction();
UNUSED(apPin)
UNUSED(nPin)
@ -791,21 +797,21 @@ HRESULT AkVCam::Pin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
HRESULT AkVCam::Pin::EndOfStream()
{
AkLogMethod();
AkLogFunction();
return E_UNEXPECTED;
}
HRESULT AkVCam::Pin::BeginFlush()
{
AkLogMethod();
AkLogFunction();
return E_UNEXPECTED;
}
HRESULT AkVCam::Pin::EndFlush()
{
AkLogMethod();
AkLogFunction();
return E_UNEXPECTED;
}
@ -814,7 +820,7 @@ HRESULT AkVCam::Pin::NewSegment(REFERENCE_TIME tStart,
REFERENCE_TIME tStop,
double dRate)
{
AkLogMethod();
AkLogFunction();
this->d->m_start = tStart;
this->d->m_stop = tStop;
this->d->m_rate = dRate;
@ -824,39 +830,46 @@ HRESULT AkVCam::Pin::NewSegment(REFERENCE_TIME tStart,
void AkVCam::PinPrivate::sendFrameOneShot()
{
AkLogMethod();
AkLogFunction();
WaitForSingleObject(this->m_sendFrameEvent, INFINITE);
this->sendFrame();
AkLoggerLog("Thread ", std::this_thread::get_id(), " finnished");
AkLogInfo() << "Thread "
<< std::this_thread::get_id()
<< " finnished"
<< std::endl;
this->m_running = false;
}
void AkVCam::PinPrivate::sendFrameLoop()
{
AkLogMethod();
AkLogFunction();
while (this->m_running) {
WaitForSingleObject(this->m_sendFrameEvent, INFINITE);
auto result = this->sendFrame();
if (FAILED(result)) {
AkLoggerLog("Error sending frame: ",
result,
": ",
stringFromResult(result));
AkLogError() << "Error sending frame: "
<< result
<< ": "
<< stringFromResult(result)
<< std::endl;
this->m_running = false;
break;
}
}
AkLoggerLog("Thread ", std::this_thread::get_id(), " finnished");
AkLogInfo() << "Thread "
<< std::this_thread::get_id()
<< " finnished"
<< std::endl;
}
HRESULT AkVCam::PinPrivate::sendFrame()
{
AkLogMethod();
AkLogFunction();
IMediaSample *sample = nullptr;
if (FAILED(this->m_memAllocator->GetBuffer(&sample,
@ -929,9 +942,9 @@ HRESULT AkVCam::PinPrivate::sendFrame()
sample->SetDiscontinuity(false);
sample->SetSyncPoint(true);
sample->SetPreroll(false);
AkLoggerLog("Sending ", stringFromMediaSample(sample));
AkLogInfo() << "Sending " << stringFromMediaSample(sample) << std::endl;
auto result = this->m_memInputPin->Receive(sample);
AkLoggerLog("Frame sent");
AkLogInfo() << "Frame sent" << std::endl;
sample->Release();
return result;
@ -1026,7 +1039,7 @@ void AkVCam::PinPrivate::propertyChanged(void *userData,
LONG lValue,
LONG Flags)
{
AkLoggerLog("PinPrivate::propertyChanged()");
AkLogFunction();
UNUSED(Flags)
auto self = reinterpret_cast<PinPrivate *>(userData);

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

@ -34,35 +34,43 @@ inline AkVCam::PluginInterface *pluginInterface()
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
UNUSED(lpvReserved)
AkLogFunction();
auto logLevel =
AkVCam::regReadInt("loglevel", AKVCAM_LOGLEVEL_DEFAULT);
AkVCam::Logger::setLogLevel(logLevel);
#if defined(QT_DEBUG) && 0
// Turn on lights
freopen("CONOUT$", "a", stdout);
freopen("CONOUT$", "a", stderr);
setbuf(stdout, nullptr);
#endif
if (AkVCam::Logger::logLevel() > AKVCAM_LOGLEVEL_DEFAULT) {
// Turn on lights
freopen("CONOUT$", "a", stdout);
freopen("CONOUT$", "a", stderr);
setbuf(stdout, nullptr);
}
auto temp = AkVCam::tempPath();
AkLoggerStart(std::string(temp.begin(), temp.end())
+ "\\" DSHOW_PLUGIN_NAME, "log");
AkLoggerLog(__FUNCTION__, "()");
auto logFile =
AkVCam::regReadString("logfile",
std::string(temp.begin(), temp.end())
+ "\\" DSHOW_PLUGIN_NAME ".log");
AkVCam::Logger::setLogFile(logFile);
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
AkLoggerLog("Reason Attach");
AkLoggerLog("Module file name: ", AkVCam::moduleFileName(hinstDLL));
AkLogInfo() << "Reason Attach" << std::endl;
AkLogInfo() << "Module file name: "
<< AkVCam::moduleFileName(hinstDLL)
<< std::endl;
DisableThreadLibraryCalls(hinstDLL);
pluginInterface()->pluginHinstance() = hinstDLL;
break;
case DLL_PROCESS_DETACH:
AkLoggerLog("Reason Detach");
AkLogInfo() << "Reason Detach" << std::endl;
break;
default:
AkLoggerLog("Reason Unknown: ", fdwReason);
AkLogInfo() << "Reason Unknown: " << fdwReason << std::endl;
break;
}
@ -72,9 +80,9 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
{
AkLoggerLog(__FUNCTION__, "()");
AkLoggerLog("CLSID: ", AkVCam::stringFromClsid(rclsid));
AkLoggerLog("IID: ", AkVCam::stringFromClsid(rclsid));
AkLogFunction();
AkLogInfo() << "CLSID: " << AkVCam::stringFromClsid(rclsid) << std::endl;
AkLogInfo() << "IID: " << AkVCam::stringFromClsid(rclsid) << std::endl;
if (!ppv)
return E_INVALIDARG;
@ -95,15 +103,14 @@ STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
STDAPI DllCanUnloadNow()
{
AkLoggerLog(__FUNCTION__, "()");
AkLogFunction();
return AkVCam::ClassFactory::locked()? S_FALSE: S_OK;
}
STDAPI DllRegisterServer()
{
AkLoggerLog(__FUNCTION__, "()");
AkLogFunction();
DllUnregisterServer();
bool ok = true;
@ -111,16 +118,17 @@ STDAPI DllRegisterServer()
for (DWORD i = 0; i < AkVCam::camerasCount(); i++) {
auto description = AkVCam::cameraDescription(i);
auto path = AkVCam::cameraPath(i);
#ifdef QT_DEBUG
auto clsid = AkVCam::createClsidFromStr(path);
#endif
AkLoggerLog("Creating Camera");
AkLoggerLog("\tDescription: ", std::string(description.begin(),
description.end()));
AkLoggerLog("\tPath: ", std::string(path.begin(), path.end()));
AkLoggerLog("\tCLSID: ", AkVCam::stringFromIid(clsid));
AkLogInfo() << "Creating Camera" << std::endl;
AkLogInfo() << "\tDescription: "
<< std::string(description.begin(),
description.end())
<< std::endl;
AkLogInfo() << "\tPath: "
<< std::string(path.begin(), path.end())
<< std::endl;
AkLogInfo() << "\tCLSID: " << AkVCam::stringFromIid(clsid) << std::endl;
ok &= pluginInterface()->createDevice(path, description);
}
@ -130,22 +138,16 @@ STDAPI DllRegisterServer()
STDAPI DllUnregisterServer()
{
AkLoggerLog(__FUNCTION__, "()");
AkLogFunction();
auto cameras =
AkVCam::listRegisteredCameras(pluginInterface()->pluginHinstance());
for (auto camera: cameras) {
AkLoggerLog("Deleting ", AkVCam::stringFromClsid(camera));
AkLogInfo() << "Deleting "
<< AkVCam::stringFromClsid(camera)
<< std::endl;
pluginInterface()->destroyDevice(camera);
}
// Unregister old virtual camera filter.
// NOTE: This code must be removed in future versions.
CLSID clsid;
CLSIDFromString(L"{41764B79-7320-5669-7274-75616C43616D}", &clsid);
AkLoggerLog("Deleting ", AkVCam::stringFromClsid(clsid));
pluginInterface()->destroyDevice(clsid);
return S_OK;
}

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

@ -26,8 +26,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "PluginInterface"
namespace AkVCam
{
class PluginInterfacePrivate
@ -62,7 +60,7 @@ HINSTANCE &AkVCam::PluginInterface::pluginHinstance()
bool AkVCam::PluginInterface::registerServer(const std::wstring &deviceId,
const std::wstring &description) const
{
AkLogMethod();
AkLogFunction();
// Define the layout in registry of the filter.
@ -70,9 +68,9 @@ bool AkVCam::PluginInterface::registerServer(const std::wstring &deviceId,
auto fileName = AkVCam::moduleFileNameW(this->d->m_pluginHinstance);
std::wstring threadingModel = L"Both";
AkLoggerLog("CLSID: ", std::string(clsid.begin(), clsid.end()));
AkLoggerLog("Description: ", std::string(description.begin(), description.end()));
AkLoggerLog("Filename: ", std::string(fileName.begin(), fileName.end()));
AkLogInfo() << "CLSID: " << std::string(clsid.begin(), clsid.end()) << std::endl;
AkLogInfo() << "Description: " << std::string(description.begin(), description.end()) << std::endl;
AkLogInfo() << "Filename: " << std::string(fileName.begin(), fileName.end()) << std::endl;
auto subkey = L"CLSID\\" + clsid;
@ -126,31 +124,31 @@ registerServer_failed:
if (keyCLSID)
RegCloseKey(keyCLSID);
AkLoggerLog("Result: ", stringFromResult(result));
AkLogInfo() << "Result: " << stringFromResult(result) << std::endl;
return ok;
}
void AkVCam::PluginInterface::unregisterServer(const std::string &deviceId) const
{
AkLogMethod();
AkLogFunction();
this->unregisterServer(createClsidFromStr(deviceId));
}
void AkVCam::PluginInterface::unregisterServer(const std::wstring &deviceId) const
{
AkLogMethod();
AkLogFunction();
this->unregisterServer(createClsidFromStr(deviceId));
}
void AkVCam::PluginInterface::unregisterServer(const CLSID &clsid) const
{
AkLogMethod();
AkLogFunction();
auto clsidStr = stringFromClsid(clsid);
AkLoggerLog("CLSID: ", clsidStr);
AkLogInfo() << "CLSID: " << clsidStr << std::endl;
auto subkey = L"CLSID\\" + std::wstring(clsidStr.begin(), clsidStr.end());
this->d->deleteTree(HKEY_CLASSES_ROOT, subkey.c_str());
@ -159,7 +157,7 @@ void AkVCam::PluginInterface::unregisterServer(const CLSID &clsid) const
bool AkVCam::PluginInterface::registerFilter(const std::wstring &deviceId,
const std::wstring &description) const
{
AkLogMethod();
AkLogFunction();
auto clsid = AkVCam::createClsidFromStr(deviceId);
IFilterMapper2 *filterMapper = nullptr;
@ -216,28 +214,28 @@ registerFilter_failed:
CoUninitialize();
AkLoggerLog("Result: ", stringFromResult(result));
AkLogInfo() << "Result: " << stringFromResult(result) << std::endl;
return ok;
}
void AkVCam::PluginInterface::unregisterFilter(const std::string &deviceId) const
{
AkLogMethod();
AkLogFunction();
this->unregisterFilter(AkVCam::createClsidFromStr(deviceId));
}
void AkVCam::PluginInterface::unregisterFilter(const std::wstring &deviceId) const
{
AkLogMethod();
AkLogFunction();
this->unregisterFilter(AkVCam::createClsidFromStr(deviceId));
}
void AkVCam::PluginInterface::unregisterFilter(const CLSID &clsid) const
{
AkLogMethod();
AkLogFunction();
IFilterMapper2 *filterMapper = nullptr;
auto result = CoInitialize(nullptr);
@ -263,20 +261,20 @@ unregisterFilter_failed:
filterMapper->Release();
CoUninitialize();
AkLoggerLog("Result: ", stringFromResult(result));
AkLogInfo() << "Result: " << stringFromResult(result) << std::endl;
}
bool AkVCam::PluginInterface::setDevicePath(const std::wstring &deviceId) const
{
AkLogMethod();
AkLogFunction();
std::wstring subKey =
L"CLSID\\"
+ wstringFromIid(CLSID_VideoInputDeviceCategory)
+ L"\\Instance\\"
+ createClsidWStrFromStr(deviceId);
AkLoggerLog("Key: HKEY_CLASSES_ROOT");
AkLoggerLog("SubKey: ", std::string(subKey.begin(), subKey.end()));
AkLogInfo() << "Key: HKEY_CLASSES_ROOT" << std::endl;
AkLogInfo() << "SubKey: " << std::string(subKey.begin(), subKey.end()) << std::endl;
HKEY hKey = nullptr;
auto result = RegOpenKeyEx(HKEY_CLASSES_ROOT,
@ -305,7 +303,7 @@ setDevicePath_failed:
if (hKey)
RegCloseKey(hKey);
AkLoggerLog("Result: ", stringFromResult(result));
AkLogInfo() << "Result: " << stringFromResult(result) << std::endl;
return ok;
}
@ -313,7 +311,7 @@ setDevicePath_failed:
bool AkVCam::PluginInterface::createDevice(const std::wstring &deviceId,
const std::wstring &description)
{
AkLogMethod();
AkLogFunction();
if (!this->registerServer(deviceId, description))
goto createDevice_failed;
@ -334,7 +332,7 @@ createDevice_failed:
void AkVCam::PluginInterface::destroyDevice(const std::string &deviceId)
{
AkLogMethod();
AkLogFunction();
this->unregisterFilter(deviceId);
this->unregisterServer(deviceId);
@ -342,7 +340,7 @@ void AkVCam::PluginInterface::destroyDevice(const std::string &deviceId)
void AkVCam::PluginInterface::destroyDevice(const std::wstring &deviceId)
{
AkLogMethod();
AkLogFunction();
this->unregisterFilter(deviceId);
this->unregisterServer(deviceId);
@ -350,7 +348,7 @@ void AkVCam::PluginInterface::destroyDevice(const std::wstring &deviceId)
void AkVCam::PluginInterface::destroyDevice(const CLSID &clsid)
{
AkLogMethod();
AkLogFunction();
this->unregisterFilter(clsid);
this->unregisterServer(clsid);

8
dshow/VirtualCamera/src/propertyset.cpp
View file

@ -23,8 +23,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "PropertySet"
AkVCam::PropertySet::PropertySet():
CUnknown(this, IID_IKsPropertySet)
{
@ -49,7 +47,7 @@ HRESULT AkVCam::PropertySet::Set(const GUID &guidPropSet,
UNUSED(cbInstanceData)
UNUSED(pPropData)
UNUSED(cbPropData)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}
@ -64,7 +62,7 @@ HRESULT AkVCam::PropertySet::Get(const GUID &guidPropSet,
{
UNUSED(pInstanceData)
UNUSED(cbInstanceData)
AkLogMethod();
AkLogFunction();
if (!IsEqualGUID(guidPropSet, AMPROPSETID_Pin))
return E_PROP_SET_UNSUPPORTED;
@ -94,7 +92,7 @@ HRESULT AkVCam::PropertySet::QuerySupported(const GUID &guidPropSet,
DWORD dwPropID,
DWORD *pTypeSupport)
{
AkLogMethod();
AkLogFunction();
if (!IsEqualGUID(guidPropSet, AMPROPSETID_Pin))
return E_PROP_SET_UNSUPPORTED;

14
dshow/VirtualCamera/src/pushsource.cpp
View file

@ -21,8 +21,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "PushSource"
AkVCam::PushSource::PushSource(IAMStreamConfig *streamConfig):
Latency(streamConfig)
{
@ -35,7 +33,7 @@ AkVCam::PushSource::~PushSource()
HRESULT AkVCam::PushSource::GetPushSourceFlags(ULONG *pFlags)
{
AkLogMethod();
AkLogFunction();
if (!pFlags)
return E_POINTER;
@ -48,7 +46,7 @@ HRESULT AkVCam::PushSource::GetPushSourceFlags(ULONG *pFlags)
HRESULT AkVCam::PushSource::SetPushSourceFlags(ULONG Flags)
{
UNUSED(Flags)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}
@ -56,7 +54,7 @@ HRESULT AkVCam::PushSource::SetPushSourceFlags(ULONG Flags)
HRESULT AkVCam::PushSource::SetStreamOffset(REFERENCE_TIME rtOffset)
{
UNUSED(rtOffset)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}
@ -64,7 +62,7 @@ HRESULT AkVCam::PushSource::SetStreamOffset(REFERENCE_TIME rtOffset)
HRESULT AkVCam::PushSource::GetStreamOffset(REFERENCE_TIME *prtOffset)
{
UNUSED(prtOffset)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}
@ -72,7 +70,7 @@ HRESULT AkVCam::PushSource::GetStreamOffset(REFERENCE_TIME *prtOffset)
HRESULT AkVCam::PushSource::GetMaxStreamOffset(REFERENCE_TIME *prtMaxOffset)
{
UNUSED(prtMaxOffset)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}
@ -80,7 +78,7 @@ HRESULT AkVCam::PushSource::GetMaxStreamOffset(REFERENCE_TIME *prtMaxOffset)
HRESULT AkVCam::PushSource::SetMaxStreamOffset(REFERENCE_TIME rtMaxOffset)
{
UNUSED(rtMaxOffset)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}

14
dshow/VirtualCamera/src/qualitycontrol.cpp
View file

@ -21,8 +21,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "QualityControl"
AkVCam::QualityControl::QualityControl():
CUnknown(this, IID_IQualityControl)
{
@ -37,15 +35,15 @@ AkVCam::QualityControl::~QualityControl()
HRESULT AkVCam::QualityControl::Notify(IBaseFilter *pSelf, Quality q)
{
UNUSED(q)
AkLogMethod();
AkLogFunction();
if (!pSelf)
return E_POINTER;
AkLoggerLog("Type: ", q.Type == Famine? "Famine": "Flood");
AkLoggerLog("Proportion: ", q.Proportion);
AkLoggerLog("Late: ", q.Late);
AkLoggerLog("TimeStamp:", q.TimeStamp);
AkLogInfo() << "Type: " << (q.Type == Famine? "Famine": "Flood") << std::endl;
AkLogInfo() << "Proportion: " << q.Proportion << std::endl;
AkLogInfo() << "Late: " << q.Late << std::endl;
AkLogInfo() << "TimeStamp:" << q.TimeStamp << std::endl;
return S_OK;
}
@ -53,7 +51,7 @@ HRESULT AkVCam::QualityControl::Notify(IBaseFilter *pSelf, Quality q)
HRESULT AkVCam::QualityControl::SetSink(IQualityControl *piqc)
{
UNUSED(piqc)
AkLogMethod();
AkLogFunction();
return E_NOTIMPL;
}

34
dshow/VirtualCamera/src/referenceclock.cpp
View file

@ -30,8 +30,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "ReferenceClock"
namespace AkVCam
{
class AdviseCookiePrivate
@ -90,7 +88,7 @@ AkVCam::ReferenceClock::~ReferenceClock()
HRESULT AkVCam::ReferenceClock::GetTime(REFERENCE_TIME *pTime)
{
AkLogMethod();
AkLogFunction();
if (!pTime)
return E_POINTER;
@ -110,7 +108,7 @@ HRESULT AkVCam::ReferenceClock::AdviseTime(REFERENCE_TIME baseTime,
HEVENT hEvent,
DWORD_PTR *pdwAdviseCookie)
{
AkLogMethod();
AkLogFunction();
this->d->cleanup();
if (!pdwAdviseCookie)
@ -136,7 +134,7 @@ HRESULT AkVCam::ReferenceClock::AdvisePeriodic(REFERENCE_TIME startTime,
HSEMAPHORE hSemaphore,
DWORD_PTR *pdwAdviseCookie)
{
AkLogMethod();
AkLogFunction();
this->d->cleanup();
if (!pdwAdviseCookie)
@ -159,7 +157,7 @@ HRESULT AkVCam::ReferenceClock::AdvisePeriodic(REFERENCE_TIME startTime,
HRESULT AkVCam::ReferenceClock::Unadvise(DWORD_PTR dwAdviseCookie)
{
AkLogMethod();
AkLogFunction();
auto it = std::find(this->d->m_cookies.begin(),
this->d->m_cookies.end(),
@ -186,7 +184,7 @@ void AkVCam::AdviseCookiePrivate::adviseTime(REFERENCE_TIME baseTime,
REFERENCE_TIME streamTime,
HEVENT hEvent)
{
AkLogMethod();
AkLogFunction();
this->m_run = true;
this->m_thread = std::thread(&AdviseCookiePrivate::adviseTimeTh,
@ -194,14 +192,14 @@ void AkVCam::AdviseCookiePrivate::adviseTime(REFERENCE_TIME baseTime,
baseTime,
streamTime,
hEvent);
AkLoggerLog("Launching thread ", this->m_thread.get_id());
AkLogInfo() << "Launching thread " << this->m_thread.get_id() << std::endl;
}
void AkVCam::AdviseCookiePrivate::adviseTimeTh(REFERENCE_TIME baseTime,
REFERENCE_TIME streamTime,
HEVENT hEvent)
{
AkLogMethod();
AkLogFunction();
REFERENCE_TIME clockTime;
this->m_clock->GetTime(&clockTime);
@ -222,14 +220,17 @@ void AkVCam::AdviseCookiePrivate::adviseTimeTh(REFERENCE_TIME baseTime,
SetEvent(HANDLE(hEvent));
this->m_run = false;
AkLoggerLog("Thread ", std::this_thread::get_id(), " finnished");
AkLogInfo() << "Thread "
<< std::this_thread::get_id()
<< " finnished"
<< std::endl;
}
void AkVCam::AdviseCookiePrivate::advisePeriodic(REFERENCE_TIME startTime,
REFERENCE_TIME periodTime,
HSEMAPHORE hSemaphore)
{
AkLogMethod();
AkLogFunction();
this->m_run = true;
this->m_thread = std::thread(&AdviseCookiePrivate::advisePeriodicTh,
@ -237,14 +238,14 @@ void AkVCam::AdviseCookiePrivate::advisePeriodic(REFERENCE_TIME startTime,
startTime,
periodTime,
hSemaphore);
AkLoggerLog("Launching thread ", this->m_thread.get_id());
AkLogInfo() << "Launching thread " << this->m_thread.get_id() << std::endl;
}
void AkVCam::AdviseCookiePrivate::advisePeriodicTh(REFERENCE_TIME startTime,
REFERENCE_TIME periodTime,
HSEMAPHORE hSemaphore)
{
AkLogMethod();
AkLogFunction();
REFERENCE_TIME clockTime;
this->m_clock->GetTime(&clockTime);
@ -271,12 +272,15 @@ void AkVCam::AdviseCookiePrivate::advisePeriodicTh(REFERENCE_TIME startTime,
this->m_mutex.unlock();
}
AkLoggerLog("Thread ", std::this_thread::get_id(), " finnished");
AkLogInfo() << "Thread "
<< std::this_thread::get_id()
<< " finnished"
<< std::endl;
}
void AkVCam::AdviseCookiePrivate::unadvise()
{
AkLogMethod();
AkLogFunction();
this->m_run = false;
this->m_mutex.lock();

8
dshow/VirtualCamera/src/specifypropertypages.cpp
View file

@ -28,8 +28,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "SpecifyPropertyPages"
namespace AkVCam
{
class SpecifyPropertyPagesPrivate
@ -55,7 +53,7 @@ AkVCam::SpecifyPropertyPages::~SpecifyPropertyPages()
HRESULT AkVCam::SpecifyPropertyPages::GetPages(CAUUID *pPages)
{
AkLogMethod();
AkLogFunction();
if (!pPages)
return E_POINTER;
@ -80,11 +78,11 @@ HRESULT AkVCam::SpecifyPropertyPages::GetPages(CAUUID *pPages)
pPages->cElems = ULONG(pages.size());
pPages->pElems =
reinterpret_cast<GUID *>(CoTaskMemAlloc(sizeof(GUID) * pages.size()));
AkLoggerLog("Returning property pages:");
AkLogInfo() << "Returning property pages:" << std::endl;
for (size_t i = 0; i < pages.size(); i++) {
memcpy(&pPages->pElems[i], &pages[i], sizeof(GUID));
AkLoggerLog(" ", stringFromClsid(pages[i]));
AkLogInfo() << " " << stringFromClsid(pages[i]) << std::endl;
}
return S_OK;

16
dshow/VirtualCamera/src/streamconfig.cpp
View file

@ -29,8 +29,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "StreamConfig"
namespace AkVCam
{
class StreamConfigPrivate
@ -62,7 +60,7 @@ void AkVCam::StreamConfig::setPin(Pin *pin)
HRESULT AkVCam::StreamConfig::SetFormat(AM_MEDIA_TYPE *pmt)
{
AkLogMethod();
AkLogFunction();
if (!pmt)
return E_POINTER;
@ -103,7 +101,7 @@ HRESULT AkVCam::StreamConfig::SetFormat(AM_MEDIA_TYPE *pmt)
HRESULT AkVCam::StreamConfig::GetFormat(AM_MEDIA_TYPE **pmt)
{
AkLogMethod();
AkLogFunction();
if (!pmt)
return E_POINTER;
@ -127,7 +125,7 @@ HRESULT AkVCam::StreamConfig::GetFormat(AM_MEDIA_TYPE **pmt)
mediaTypes->Release();
}
AkLoggerLog("MediaType: ", stringFromMediaType(*pmt));
AkLogInfo() << "MediaType: " << stringFromMediaType(*pmt) << std::endl;
return *pmt? S_OK: E_FAIL;
}
@ -135,7 +133,7 @@ HRESULT AkVCam::StreamConfig::GetFormat(AM_MEDIA_TYPE **pmt)
HRESULT AkVCam::StreamConfig::GetNumberOfCapabilities(int *piCount,
int *piSize)
{
AkLogMethod();
AkLogFunction();
if (!piCount || !piSize)
return E_POINTER;
@ -169,7 +167,7 @@ HRESULT AkVCam::StreamConfig::GetStreamCaps(int iIndex,
AM_MEDIA_TYPE **pmt,
BYTE *pSCC)
{
AkLogMethod();
AkLogFunction();
if (!pmt || !pSCC)
return E_POINTER;
@ -247,7 +245,7 @@ HRESULT AkVCam::StreamConfig::GetStreamCaps(int iIndex,
configCaps->ShrinkTapsX = 1;
configCaps->ShrinkTapsY = 1;
configCaps->MinFrameInterval = format->AvgTimePerFrame;
configCaps->MaxFrameInterval = format->AvgTimePerFrame;
configCaps->MaxFrameInterval = format->AvgTimePerFrame;
configCaps->MinBitsPerSecond = LONG(format->dwBitRate);
configCaps->MaxBitsPerSecond = LONG(format->dwBitRate);
}
@ -262,7 +260,7 @@ HRESULT AkVCam::StreamConfig::GetStreamCaps(int iIndex,
}
}
AkLoggerLog("Media Type: ", stringFromMediaType(*pmt));
AkLogInfo() << "Media Type: " << stringFromMediaType(*pmt) << std::endl;
return *pmt? S_OK: S_FALSE;
}

14
dshow/VirtualCamera/src/videocontrol.cpp
View file

@ -31,8 +31,6 @@
#include "VCamUtils/src/utils.h"
#include "VCamUtils/src/image/videoformat.h"
#define AK_CUR_INTERFACE "VideoControl"
namespace AkVCam
{
class VideoControlPrivate
@ -58,7 +56,7 @@ AkVCam::VideoControl::~VideoControl()
HRESULT AkVCam::VideoControl::GetCaps(IPin *pPin, LONG *pCapsFlags)
{
AkLogMethod();
AkLogFunction();
if (!pPin || !pCapsFlags)
return E_POINTER;
@ -86,7 +84,7 @@ HRESULT AkVCam::VideoControl::GetCaps(IPin *pPin, LONG *pCapsFlags)
HRESULT AkVCam::VideoControl::SetMode(IPin *pPin, LONG Mode)
{
AkLogMethod();
AkLogFunction();
if (!pPin)
return E_POINTER;
@ -114,7 +112,7 @@ HRESULT AkVCam::VideoControl::SetMode(IPin *pPin, LONG Mode)
HRESULT AkVCam::VideoControl::GetMode(IPin *pPin, LONG *Mode)
{
AkLogMethod();
AkLogFunction();
if (!pPin || !Mode)
return E_POINTER;
@ -149,7 +147,7 @@ HRESULT AkVCam::VideoControl::GetMode(IPin *pPin, LONG *Mode)
HRESULT AkVCam::VideoControl::GetCurrentActualFrameRate(IPin *pPin,
LONGLONG *ActualFrameRate)
{
AkLogMethod();
AkLogFunction();
if (!pPin || !ActualFrameRate)
return E_POINTER;
@ -202,7 +200,7 @@ HRESULT AkVCam::VideoControl::GetMaxAvailableFrameRate(IPin *pPin,
SIZE Dimensions,
LONGLONG *MaxAvailableFrameRate)
{
AkLogMethod();
AkLogFunction();
if (!pPin || !MaxAvailableFrameRate)
return E_POINTER;
@ -256,7 +254,7 @@ HRESULT AkVCam::VideoControl::GetFrameRateList(IPin *pPin,
LONG *ListSize,
LONGLONG **FrameRates)
{
AkLogMethod();
AkLogFunction();
if (!pPin || !ListSize || !FrameRates)
return E_POINTER;

8
dshow/VirtualCamera/src/videoprocamp.cpp
View file

@ -25,8 +25,6 @@
#include "PlatformUtils/src/utils.h"
#include "VCamUtils/src/utils.h"
#define AK_CUR_INTERFACE "VideoProcAmp"
namespace AkVCam
{
class VideoProcAmpPrivate
@ -88,7 +86,7 @@ HRESULT AkVCam::VideoProcAmp::GetRange(LONG Property,
LONG *pDefault,
LONG *pCapsFlags)
{
AkLogMethod();
AkLogFunction();
if (!pMin || !pMax || !pSteppingDelta || !pDefault || !pCapsFlags)
return E_POINTER;
@ -115,7 +113,7 @@ HRESULT AkVCam::VideoProcAmp::GetRange(LONG Property,
HRESULT AkVCam::VideoProcAmp::Set(LONG Property, LONG lValue, LONG Flags)
{
AkLogMethod();
AkLogFunction();
for (auto &control: ProcAmpPrivate::controls())
if (control.property == Property) {
@ -135,7 +133,7 @@ HRESULT AkVCam::VideoProcAmp::Set(LONG Property, LONG lValue, LONG Flags)
HRESULT AkVCam::VideoProcAmp::Get(LONG Property, LONG *lValue, LONG *Flags)
{
AkLogMethod();
AkLogFunction();
if (!lValue || !Flags)
return E_POINTER;

4
ports/deploy/installscript.mac.qs
View file

@ -59,6 +59,10 @@ Component.prototype.createOperations = function()
+ " <key>org.webcamoid.cmio.AkVCam.Assistant</key>\n"
+ " <true/>\n"
+ " </dict>\n"
+ " <key>StandardOutPath</key>\n"
+ " <string>/tmp/AkVCamAssistant.log</string>\n"
+ " <key>StandardErrorPath</key>\n"
+ " <string>/tmp/AkVCamAssistant.log</string>\n"
+ " </dict>\n"
+ "</plist>\n";
component.addElevatedOperation("Delete", daemonPlist);