void PluginFactory::load()
{
rescan();
for( PluginInfoList::iterator it = infoList.begin(); it != infoList.end(); ++it ) {
PluginInfo *pluginInfo = (*it).first;
QLibrary *lib = (*it).second;
if ( !pluginInfo || !lib ) continue;
PTRACE( 1, "\n '" << pluginInfo->name << "':\n" <<
"\tdescription:\t" << pluginInfo->description << "\n" <<
"\tauthor:\t\t" << pluginInfo->author );
Plugin::Type type = pluginInfo->type;
int id = pluginInfo->id;
Plugin *plugin = 0;
if( onStartupMap.contains(id) ) {
if( onStartupMap[id] == NotLoad ) continue;
plugin = createPlugin( *it );
}
else {
if( ancaConf->readBoolEntry( LOAD_NEW_PLUGINS, LOAD_NEW_PLUGINS_DEFAULT ) && noConflicts(type) ) {
onStartupMap[id] = Load;
plugin = createPlugin( *it );
}
else
onStartupMap[id] = NotLoad;
}
// create GUI that plugin exports?
if( pluginInfo->flags & P_HAS_GUI ) d->guiPlugins.append(plugin);
}
}
void PluginFactory::load( const PluginInfoPair& pair )
{
PTRACE( 6, "PluginFactory::load" );
PluginInfo *pluginInfo = pair.first;
if( !pluginInfo ) return;
int id = pluginInfo->id;
onStartupMap[id] = Load;
if( loaded(pair) ) return;
Plugin *plugin = createPlugin( pair );
// create GUI that plugin exports?
if( pluginInfo->flags & P_HAS_GUI ) {
PTRACE( 1, "Creating GUI of plugin " << plugin->name() );
QWidget *widget = plugin->createGUI();
if ( widget ) {
emit insertWidget( widget, plugin->type(), plugin->text(), plugin->icon(), plugin->significance(), plugin->guiType() );
insertedWidgets[id] = widget;
if( d->paletteSet ) setGUIPluginsPalette(d->currentPalette);
} else
PTRACE( 1, "Failed" );
}
}
void MainHostWindow::filesDropped (const StringArray& files, int x, int y)
{
if (files.size() == 1 && File (files[0]).hasFileExtension (filenameSuffix))
{
GraphDocumentComponent* const graphEditor = getGraphEditor();
if (graphEditor != 0
&& graphEditor->graph.saveIfNeededAndUserAgrees() == FileBasedDocument::savedOk)
{
graphEditor->graph.loadFrom (File (files[0]), true);
}
}
else
{
OwnedArray <PluginDescription> typesFound;
knownPluginList.scanAndAddDragAndDroppedFiles (files, typesFound);
GraphDocumentComponent* const graphEditor = getGraphEditor();
if (graphEditor != 0)
relativePositionToOtherComponent (graphEditor, x, y);
for (int i = 0; i < jmin (5, typesFound.size()); ++i)
createPlugin (typesFound.getUnchecked(i), x, y);
}
}
//============================================================
// plugin holder
//============================================================
StandalonePluginHolder::StandalonePluginHolder ()
{
createPlugin("", Point<float>(1.f, 1.f));
setupAudioDevices();
reloadPluginState();
startPlaying();
}
CIMIPlugin*
CIMIPluginManager::loadPlugin(std::string filename)
{
TPluginTypeEnum type = detectPluginType(filename);
CIMIPlugin* plugin = createPlugin(filename, type);
std::stringstream error;
if (plugin == NULL) {
return NULL;
}
if (hasLastError()) {
delete plugin;
return NULL;
}
for (size_t i = 0; i < m_plugins.size(); i++) {
if (m_plugins[i]->getName() == plugin->getName()) {
error << "Plugin " << plugin->getName() << " has already loaded!";
setLastError(error.str());
delete plugin; // Reject duplicate plugins
return NULL;
}
}
m_plugins.push_back(plugin);
return plugin;
}
QObject* QWebPage_QtDShell::__override_createPlugin(const QString& classid0, const QUrl& url1, const QStringList& paramNames2, const QStringList& paramValues3, bool static_call)
{
if (static_call) {
return QWebPage::createPlugin((const QString& )classid0, (const QUrl& )url1, (const QStringList& )paramNames2, (const QStringList& )paramValues3);
} else {
return createPlugin((const QString& )classid0, (const QUrl& )url1, (const QStringList& )paramNames2, (const QStringList& )paramValues3);
}
}
/// Handler for factories of type: ConstructionFactory
void* createPlugin(const std::string& factory,
Geometry::LCDD& lcdd,
const std::string& arg,
void* (*cast)(void*)) {
char* argv[] = { (char*)arg.c_str(), 0 };
int argc = 1;
return createPlugin(factory, lcdd, argc, argv, cast);
}
/// Handler for factories of type: ConstructionFactory
void* createPlugin(const std::string& factory,
Detector& description,
const std::string& arg,
void* (*cast)(void*)) {
char* argv[] = { (char*)arg.c_str(), 0 };
int argc = 1;
return createPlugin(factory, description, argc, argv, cast);
}
DataObjectPtr DataObject::createPlugin(const QString& name) {
#if 0
KService::List sl = KServiceTypeTrader::self()->query("Kst Data Object");
for (KService::List::ConstIterator it = sl.begin(); it != sl.end(); ++it) {
if ((*it)->name() != name) {
continue;
} else if (DataObjectPtr object = createPlugin(*it)) {
return object;
}
}
#endif
return 0L;
}
bool TcpSession::onTcpEstablished()
{
status = TCP_STATUS_ESTABLISHED;
if (listener && listener->onTcpEstablished())
return true;
OutPacket *p = createPacket(TCP_HELLO);
*p << (uint8) isSend;
sendDirect(p);
delete p;
createPlugin();
return true;
}
bool TcpSession::onPacketReceived(TcpInPacket &in)
{
uint16 cmd = in.getCmd();
if (cmd == TCP_HELLO) {
if (status != TCP_STATUS_HELLO_WAIT)
return false;
status = TCP_STATUS_ESTABLISHED;
uin = in.getUIN();
uint8 b;
in >> b;
isSend = !b;
if (!listener)
createPlugin();
} else if (status == TCP_STATUS_HELLO_WAIT || uin != in.getUIN())
//==============================================================================
EXPORT bool __cdecl PLG_CALLBACK(GenericPluginLoadState loadState)
{
static PluginMain* s_pluginMain = nullptr;
auto contextManager = s_GetContextFunc();
TF_ASSERT(contextManager);
auto staticInitializer = contextManager->queryInterface<IStaticInitalizer>();
if (staticInitializer)
{
staticInitializer->initStatics(*contextManager);
}
switch (loadState)
{
case GenericPluginLoadState::Create:
s_pluginMain = createPlugin(*contextManager);
return true;
case GenericPluginLoadState::PostLoad:
return s_pluginMain->PostLoad(*contextManager);
case GenericPluginLoadState::Initialise:
s_pluginMain->Initialise(*contextManager);
return true;
case GenericPluginLoadState::Finalise:
return s_pluginMain->Finalise(*contextManager);
case GenericPluginLoadState::Unload:
s_pluginMain->Unload(*contextManager);
return true;
case GenericPluginLoadState::Destroy:
if (staticInitializer)
{
staticInitializer->destroy();
}
delete s_pluginMain;
s_pluginMain = nullptr;
return true;
default:
break;
}
return false;
}
bool PluginManagerPrivate::setInfo(const char *name)
{
pluginInfo *info = getInfo(name);
if (info == NULL)
return false;
if (info->bDisabled){
if (info->plugin == NULL)
return false;
release(*info);
load(*info);
return true;
}
if (info->plugin)
return false;
info->bFromCfg = true;
load(*info);
createPlugin(*info);
return true;
}
void MainHostWindow::menuItemSelected (int menuItemID, int /*topLevelMenuIndex*/)
{
GraphDocumentComponent* const graphEditor = getGraphEditor();
if (menuItemID == 250)
{
if (graphEditor != 0)
graphEditor->graph.clear();
}
else if (menuItemID >= 100 && menuItemID < 200)
{
RecentlyOpenedFilesList recentFiles;
recentFiles.restoreFromString (ApplicationProperties::getInstance()->getUserSettings()
->getValue ("recentFilterGraphFiles"));
if (graphEditor != 0 && graphEditor->graph.saveIfNeededAndUserAgrees() == FileBasedDocument::savedOk)
graphEditor->graph.loadFrom (recentFiles.getFile (menuItemID - 100), true);
}
else if (menuItemID >= 200 && menuItemID < 210)
{
if (menuItemID == 200)
pluginSortMethod = KnownPluginList::defaultOrder;
else if (menuItemID == 201)
pluginSortMethod = KnownPluginList::sortAlphabetically;
else if (menuItemID == 202)
pluginSortMethod = KnownPluginList::sortByCategory;
else if (menuItemID == 203)
pluginSortMethod = KnownPluginList::sortByManufacturer;
else if (menuItemID == 204)
pluginSortMethod = KnownPluginList::sortByFileSystemLocation;
ApplicationProperties::getInstance()->getUserSettings()
->setValue (T("pluginSortMethod"), (int) pluginSortMethod);
}
else
{
createPlugin (getChosenType (menuItemID),
proportionOfWidth (0.3f + Random::getSystemRandom().nextFloat() * 0.6f),
proportionOfHeight (0.3f + Random::getSystemRandom().nextFloat() * 0.6f));
}
}
PluginExporter()
: fPlugin(createPlugin()),
fData((fPlugin != nullptr) ? fPlugin->pData : nullptr),
fIsActive(false)
{
DISTRHO_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
DISTRHO_SAFE_ASSERT_RETURN(fData != nullptr,);
for (uint32_t i=0, count=fData->parameterCount; i < count; ++i)
fPlugin->d_initParameter(i, fData->parameters[i]);
#if DISTRHO_PLUGIN_WANT_PROGRAMS
for (uint32_t i=0, count=fData->programCount; i < count; ++i)
fPlugin->d_initProgramName(i, fData->programNames[i]);
#endif
#if DISTRHO_PLUGIN_WANT_STATE
for (uint32_t i=0, count=fData->stateCount; i < count; ++i)
fPlugin->d_initState(i, fData->stateKeys[i], fData->stateDefValues[i]);
#endif
}
void MainHostWindow::filesDropped (const StringArray& files, int x, int y)
{
GraphDocumentComponent* const graphEditor = getGraphEditor();
if (graphEditor != nullptr)
{
if (files.size() == 1 && File (files[0]).hasFileExtension (filenameSuffix))
{
if (graphEditor->graph.saveIfNeededAndUserAgrees() == FileBasedDocument::savedOk)
graphEditor->graph.loadFrom (File (files[0]), true);
}
else
{
OwnedArray <PluginDescription> typesFound;
knownPluginList.scanAndAddDragAndDroppedFiles (formatManager, files, typesFound);
Point<int> pos (graphEditor->getLocalPoint (this, Point<int> (x, y)));
for (int i = 0; i < jmin (5, typesFound.size()); ++i)
createPlugin (typesFound.getUnchecked(i), pos.getX(), pos.getY());
}
}
}
bool PluginManagerPrivate::create(pluginInfo &info)
{
if (info.plugin)
return true;
string param;
string descr;
const char *short_name = info.name;
for (; *short_name; short_name++){
char c = *short_name;
if ((c >= '0') && (c <= '9')) continue;
break;
}
string value;
param = "--enable-";
param += short_name;
if (findParam(param.c_str(), NULL, &value)){
info.bDisabled = false;
info.bFromCfg = true;
}
param = "--disable-";
param += short_name;
if (findParam(param.c_str(), NULL, &value)){
info.bDisabled = true;
info.bFromCfg = true;
}
if (info.bDisabled)
return false;
load(info);
if (info.info == NULL)
return false;
if (m_bInInit && (info.info->flags & (PLUGIN_PROTOCOL & ~PLUGIN_NOLOAD_DEFAULT))){
info.bDisabled = true;
release(info);
return false;
}
return createPlugin(info);
}
status_t BnCrypto::onTransact(
uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
switch (code) {
case INIT_CHECK:
{
CHECK_INTERFACE(ICrypto, data, reply);
reply->writeInt32(initCheck());
return OK;
}
case IS_CRYPTO_SUPPORTED:
{
CHECK_INTERFACE(ICrypto, data, reply);
uint8_t uuid[16];
data.read(uuid, sizeof(uuid));
reply->writeInt32(isCryptoSchemeSupported(uuid));
return OK;
}
case CREATE_PLUGIN:
{
CHECK_INTERFACE(ICrypto, data, reply);
uint8_t uuid[16];
data.read(uuid, sizeof(uuid));
size_t opaqueSize = data.readInt32();
void *opaqueData = NULL;
if (opaqueSize > 0) {
opaqueData = malloc(opaqueSize);
CHECK(opaqueData != NULL);
data.read(opaqueData, opaqueSize);
}
reply->writeInt32(createPlugin(uuid, opaqueData, opaqueSize));
if (opaqueData != NULL) {
free(opaqueData);
opaqueData = NULL;
}
return OK;
}
case DESTROY_PLUGIN:
{
CHECK_INTERFACE(ICrypto, data, reply);
reply->writeInt32(destroyPlugin());
return OK;
}
case REQUIRES_SECURE_COMPONENT:
{
CHECK_INTERFACE(ICrypto, data, reply);
const char *mime = data.readCString();
reply->writeInt32(requiresSecureDecoderComponent(mime));
return OK;
}
case DECRYPT:
{
CHECK_INTERFACE(ICrypto, data, reply);
bool secure = data.readInt32() != 0;
CryptoPlugin::Mode mode = (CryptoPlugin::Mode)data.readInt32();
uint8_t key[16];
data.read(key, sizeof(key));
uint8_t iv[16];
data.read(iv, sizeof(iv));
size_t totalSize = data.readInt32();
sp<IMemory> sharedBuffer =
interface_cast<IMemory>(data.readStrongBinder());
int32_t offset = data.readInt32();
int32_t numSubSamples = data.readInt32();
CryptoPlugin::SubSample *subSamples =
new CryptoPlugin::SubSample[numSubSamples];
data.read(
subSamples,
sizeof(CryptoPlugin::SubSample) * numSubSamples);
void *secureBufferId, *dstPtr;
if (secure) {
secureBufferId = reinterpret_cast<void *>(static_cast<uintptr_t>(data.readInt64()));
AVMediaUtils::get()->readCustomData(&data, &secureBufferId);
} else {
dstPtr = malloc(totalSize);
CHECK(dstPtr != NULL);
}
AString errorDetailMsg;
ssize_t result;
size_t sumSubsampleSizes = 0;
bool overflow = false;
for (int32_t i = 0; i < numSubSamples; ++i) {
CryptoPlugin::SubSample &ss = subSamples[i];
if (sumSubsampleSizes <= SIZE_MAX - ss.mNumBytesOfEncryptedData) {
sumSubsampleSizes += ss.mNumBytesOfEncryptedData;
} else {
overflow = true;
}
if (sumSubsampleSizes <= SIZE_MAX - ss.mNumBytesOfClearData) {
sumSubsampleSizes += ss.mNumBytesOfClearData;
} else {
overflow = true;
}
}
if (overflow || sumSubsampleSizes != totalSize) {
result = -EINVAL;
} else if (offset + totalSize > sharedBuffer->size()) {
result = -EINVAL;
} else {
result = decrypt(
secure,
key,
iv,
mode,
sharedBuffer, offset,
subSamples, numSubSamples,
secure ? secureBufferId : dstPtr,
&errorDetailMsg);
}
reply->writeInt32(result);
if (isCryptoError(result)) {
reply->writeCString(errorDetailMsg.c_str());
}
if (!secure) {
if (result >= 0) {
CHECK_LE(result, static_cast<ssize_t>(totalSize));
reply->write(dstPtr, result);
}
free(dstPtr);
dstPtr = NULL;
} else {
AVMediaUtils::get()->closeFileDescriptor(secureBufferId);
}
delete[] subSamples;
subSamples = NULL;
return OK;
}
case NOTIFY_RESOLUTION:
{
CHECK_INTERFACE(ICrypto, data, reply);
int32_t width = data.readInt32();
int32_t height = data.readInt32();
notifyResolution(width, height);
return OK;
}
case SET_MEDIADRM_SESSION:
{
CHECK_INTERFACE(IDrm, data, reply);
Vector<uint8_t> sessionId;
readVector(data, sessionId);
reply->writeInt32(setMediaDrmSession(sessionId));
return OK;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
/// Handler for factories of type: ConstructionFactory
void* createPlugin(const std::string& factory, Geometry::LCDD& lcdd, void* (*cast)(void*))
{
char* argv[] = {0};
int argc = 0;
return createPlugin(factory, lcdd, argc, argv, cast);
}
/// Handler for factories of type: ConstructionFactory
void* createPlugin(const std::string& factory, Detector& description, void* (*cast)(void*)) {
char* argv[] = {0};
int argc = 0;
return createPlugin(factory, description, argc, argv, cast);
}
