bool SettingsManager::loadVariable(QIODevice* in, bool append)
{
if (!in || !in->isOpen() || !in->isReadable()) {
qDebug() << "SettingsManager::loadVariableFromFile: Is not open or is not readable";
return false;
}
QDataStream stream(in);
stream.setVersion(QDataStream::Qt_4_6);
QVariant v;
stream >> v;
if (append) {
QHash<QString, QVariant> hash = v.toHash();
QHash<QString, QVariant>::const_iterator i = hash.constBegin();
while (i != hash.constEnd()) {
m_variables.insert(i.key(), i.value());
++i;
}
}
else {
m_variables = v.toHash();
}
return true;
}
bool FBXMLHandler::endElement( const QString & /*namespaceURI*/,
const QString & /*localName*/,
const QString & /*qName*/ )
{
flushCharacters();
QVariant c = iStack [iStack.count() - 1] ;
QString name = topName();
iStack.removeLast();
iNameStack.removeLast();
if (!iStack.count())
{
iRootObject = c;
iRootName = name;
}
else
{
QVariant tC = iStack[iStack.count() - 1] ;
if (tC.isNull())
{
tC = QVariantHash();
iStack.replace(iStack.count() - 1, tC);
}
if (tC.type() == QVariant::List)
{
QVariantList list = tC.toList();
list.append( c.toHash() );
iStack.replace( iStack.count() - 1 , list);
}
else if (tC.type() == QVariant::Hash)
{
QVariantHash hash = tC.toHash();
if (c.isNull())
{
c = QString("");
}
hash.insert( name, c );
iStack.replace( iStack.count() - 1 , hash);
}
}
return true;
}
void TarryTown::breakpoint() {
qDebug() << "Entering debugging mode";
QTextStream in(stdin);
QTextStream out(stdout);
QString to_eval;
while (to_eval != "cont") {
out << "> ";
out.flush();
to_eval = in.readLine();
to_eval = to_eval.replace(QString("\n"),"");
if (to_eval != "cont") {
QScriptValue result = p_engine->evaluate(to_eval);
if (p_engine->hasUncaughtException()) {
QStringList backtrace = p_engine->uncaughtExceptionBacktrace();
fprintf (stderr, " %s\n\n", qPrintable(backtrace.join("\n")));
} else {
QVariant value = result.toVariant();
if (value.type() == QMetaType::QVariantMap) {
qDebug() << "=> " << value.toMap();
} else if (value.type() == QMetaType::QVariantList) {
qDebug() << "=> " << value.toList();
} else if (value.type() == QMetaType::QVariantHash) {
qDebug() << "=> " << value.toHash();
} else if (value.type() == QMetaType::QString) {
qDebug() << "=> \n" << value.toString();
} else {
qDebug() << "=> " << value;
}
} // if (p_engine->hasUncaughtException())
}
}
}
void setOptionsForQObject(const QVariant& opt, QObject *obj)
{
if (!opt.isValid())
return;
qDebug() << QStringLiteral("set %1(%2) meta properties:").arg(QLatin1String(obj->metaObject()->className())).arg(obj->objectName());
if (opt.type() == QVariant::Hash) {
QVariantHash options(opt.toHash());
if (options.isEmpty())
return;
QHashIterator<QString, QVariant> i(options);
while (i.hasNext()) {
i.next();
if (i.value().type() == QVariant::Hash) // for example "vaapi": {...}
continue;
obj->setProperty(i.key().toUtf8().constData(), i.value());
qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
}
if (opt.type() != QVariant::Map)
return;
QVariantMap options(opt.toMap());
if (options.isEmpty())
return;
QMapIterator<QString, QVariant> i(options);
while (i.hasNext()) {
i.next();
if (i.value().type() == QVariant::Map) // for example "vaapi": {...}
continue;
obj->setProperty(i.key().toUtf8().constData(), i.value());
qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
}
QByteArray
toJson( const QVariant &variant, bool* ok )
{
#if QT_VERSION >= QT_VERSION_CHECK( 5, 0, 0 )
QVariant _variant = variant;
if ( variant.type() == QVariant::Hash )
{
// QJsonDocument cannot deal with QVariantHash, so convert.
const QVariantHash hash = variant.toHash();
QVariantMap map;
QHashIterator<QString, QVariant> it(hash);
while ( it.hasNext() )
{
it.next();
map.insert( it.key(), it.value() );
}
_variant = map;
}
QJsonDocument doc = QJsonDocument::fromVariant( _variant );
if ( ok != NULL )
{
*ok = !doc.isNull();
}
return doc.toJson( QJsonDocument::Compact );
#else
QJson::Serializer serializer;
return serializer.serialize( variant, ok );
#endif
}
/*!
\~english
Exports the all flash variants.
\~japanese
すべてのフラッシュオブジェクトをエクスポートする
*/
void TActionController::exportAllFlashVariants()
{
QVariant var = sessionStore.take(FLASH_VARS_SESSION_KEY);
if (!var.isNull()) {
exportVariants(var.toHash());
}
}
void Keyboard::handleInfo(QVariant const& properties)
{
bool ok = false;
QVariantHash items = properties.toHash();
QString newSize = items[QString::fromLatin1("size")].toString();
QVariantHash locale = items[QString::fromLatin1("locale")].toHash();
int intSize = newSize.toInt(&ok);
if (!locale.isEmpty())
{
QString languageId = locale[QString::fromLatin1("languageId")].toString();
QString countryId = locale[QString::fromLatin1("countryId")].toString();
if (!languageId.isEmpty())
mLanguageId = languageId;
if (!countryId.isEmpty())
mCountryId = countryId;
}
if (ok && intSize != mKeyboardHeight) {
mKeyboardHeight = intSize;
emit notifyHeightChanged(mKeyboardHeight);
}
#ifdef PPS_KEYBOARD_DEBUG
qDebug() << "Keyboard: height:" << mKeyboardHeight << " languageId:" << mLanguageId
<< " countryId:" << mCountryId;
#endif
}
void LuaEngine::luaPush(const QVariant& variant)
{
switch (variant.type())
{
case QVariant::Bool:
{
luaPush(variant.toBool());
break;
}
case QVariant::String:
{
luaPush(variant.toString());
break;
}
case QVariant::Int:
{
luaPush(variant.toInt());
break;
}
case QVariant::Map:
{
luaPush(variant.toMap());
break;
}
case QVariant::Hash:
{
luaPush(variant.toHash());
break;
}
default:
break;
}
}
FormGenAcceptResult FormGenRecordComposition::acceptsValueImpl(const QVariant &val) const
{
if( variantType(val) != QMetaType::QVariantHash )
return FormGenAcceptResult::reject({}, val);
QVariantHash hash = val.toHash();
QStringList valueStringList;
QSet<QString> processedTags;
for( const auto &elm : mElements ) {
auto elementAccepts = elm.element->acceptsValue(hash.value(elm.tag));
if( ! elementAccepts.acceptable ) {
QString path = elm.tag;
if( ! elementAccepts.path.isEmpty() )
path += QString("/%1").arg(elementAccepts.path);
return FormGenAcceptResult::reject(path, elementAccepts.value);
}
valueStringList.append(FormGenElement::keyStringValuePair(elm.tag, elementAccepts.valueString));
processedTags.insert(elm.tag);
}
QSet<QString> remainingTags = hash.keys().toSet() - processedTags;
if( ! remainingTags.isEmpty() )
return FormGenAcceptResult::reject(*remainingTags.cbegin(),
hash.value(*remainingTags.cbegin()));
return FormGenAcceptResult::accept(val, FormGenElement::objectString(valueStringList));
}
Command Command::fromQVariant(const QVariant &variant)
{
const QHash<QString, QVariant> hash = variant.toHash();
const QString namePref = QLatin1String("Name");
const QString executablePref = QLatin1String("Command");
const QString argumentsPref = QLatin1String("Arguments");
const QString workingDirectoryPref = QLatin1String("WorkingDirectory");
const QString enablePref = QLatin1String("Enabled");
const QString shortcutPref = QLatin1String("Shortcut");
const QString showOutputPref = QLatin1String("ShowOutput");
const QString saveBeforeExecutePref = QLatin1String("SaveBeforeExecute");
Command command;
if (hash.contains(enablePref))
command.isEnabled = hash[enablePref].toBool();
if (hash.contains(namePref))
command.name = hash[namePref].toString();
if (hash.contains(executablePref))
command.executable = hash[executablePref].toString();
if (hash.contains(argumentsPref))
command.arguments = hash[argumentsPref].toString();
if (hash.contains(workingDirectoryPref))
command.workingDirectory = hash[workingDirectoryPref].toString();
if (hash.contains(shortcutPref))
command.shortcut = hash[shortcutPref].value<QKeySequence>();
if (hash.contains(showOutputPref))
command.showOutput = hash[showOutputPref].toBool();
if (hash.contains(saveBeforeExecutePref))
command.saveBeforeExecute = hash[saveBeforeExecutePref].toBool();
return command;
}
void Session::persistSession(const QString &sessionId, const QVariant &data) const
{
const QString &sessionFile = SessionPrivate::filePath(sessionId);
const QVariantHash &hash = data.toHash();
if (hash.isEmpty()) {
qCDebug(C_SESSION) << "Clearing session values on" << sessionFile;
bool ret = QFile::remove(sessionFile);
if (!ret) {
QSettings settings(sessionFile, QSettings::IniFormat);
settings.clear();
}
} else {
qCDebug(C_SESSION) << "Persisting session values to" << sessionFile;
QSettings settings(sessionFile, QSettings::IniFormat);
settings.beginGroup(QLatin1String("Data"));
QVariantHash::ConstIterator it = hash.constBegin();
while (it != hash.constEnd()) {
if (it.value().isNull()) {
settings.remove(it.key());
} else {
settings.setValue(it.key(), it.value());
}
++it;
}
settings.endGroup();
}
}
bool ZrpcResponsePacket::fromVariant(const QVariant &in)
{
if(in.type() != QVariant::Hash)
return false;
QVariantHash obj = in.toHash();
if(!obj.contains("id") || obj["id"].type() != QVariant::ByteArray)
return false;
id = obj["id"].toByteArray();
if(!obj.contains("success") || obj["success"].type() != QVariant::Bool)
return false;
success = obj["success"].toBool();
value.clear();
condition.clear();
if(success)
{
if(!obj.contains("value"))
return false;
value = obj["value"];
}
else
{
if(!obj.contains("condition") || obj["condition"].type() != QVariant::ByteArray)
return false;
condition = obj["condition"].toByteArray();
}
return true;
}
QString EvaluateSubExpression(const QString& subexpr, const QVariant& v) {
if (subexpr.size() == 0) {
// limit the displayed decimal places
if ((QMetaType::Type)v.type() == QMetaType::Double) {
return QString::number(v.toDouble(), 'f', 2);
}
return v.toString();
} else if (subexpr.at(0) == '[') {
int rightbracket = subexpr.indexOf(']');
if (rightbracket > 0) {
bool ok = false;
int index = subexpr.mid(1, rightbracket-1).toInt(&ok);
if (ok && (QMetaType::Type)v.type() == QMetaType::QVariantList) {
return EvaluateSubExpression(subexpr.mid(rightbracket + 1),
v.toList().at(index));
}
}
} else {
int dot = subexpr.indexOf('.');
QString key = subexpr.mid(0, dot);
if ((QMetaType::Type)v.type() == QMetaType::QVariantHash) {
QHash<QString, QVariant> h = v.toHash();
QHash<QString, QVariant>::const_iterator it = h.find(key);
if (it != h.end())
return EvaluateSubExpression(subexpr.mid(key.length() + 1), *it);
} else if ((QMetaType::Type)v.type() == QMetaType::QVariantMap) {
QMap<QString, QVariant> h = v.toMap();
QMap<QString, QVariant>::const_iterator it = h.find(key);
if (it != h.end())
return EvaluateSubExpression(subexpr.mid(key.length() + 1), *it);
}
}
return "";
}
bool ConnectionManager2::applyConfig(QVariant const & config)
{
if (config.type() != QVariant::List)
return false;
QList<Connection *> newConns;
struct cleanup
{
QList<Connection *> & conns;
cleanup(QList<Connection *> & conns) : conns(conns) {}
~cleanup() { for (int i = 0; i < conns.size(); ++i) conns[i]->releaseAll(); }
} cleanupGuard(newConns);
QList<QVariant> const & connConfigs = config.toList();
for (int i = 0; i < connConfigs.size(); ++i)
{
if (connConfigs[i].type() != QVariant::Hash)
return false;
QHash<QString, QVariant> const & connConfig = connConfigs[i].toHash();
QVariant typev = connConfig.value("type");
if (typev.type() != QVariant::String)
return false;
QString const & type = typev.toString();
ConnectionPointer<Connection> conn;
if (type == "serial_port")
conn.reset(new SerialPort());
else if (type == "tcp_client")
conn.reset(new TcpSocket());
else if (type == "udp_socket")
conn.reset(new UdpSocket());
#ifdef HAVE_LIBYB
else if (type == "usb_yb_acm")
conn.reset(new UsbAcmConnection2(m_yb_runner));
#endif
if (!conn)
return false;
QVariant settings = connConfig.value("settings");
if (settings.type() != QVariant::Hash || !conn->applyConfig(settings.toHash()))
return false;
newConns.push_back(conn.data());
conn.take();
}
this->clearUserOwnedConns();
while (!newConns.empty())
{
this->addUserOwnedConn(newConns.back());
newConns.pop_back();
}
return true;
}
QVariant variantMapValue(const QVariant& value, const QString& key)
{
if (value.userType() == QVariant::Map) {
return value.toMap().value(key);
} else {
return value.toHash().value(key);
}
}
void
CredentialsManager::keychainJobFinished( QKeychain::Job* j )
{
tDebug() << Q_FUNC_INFO;
if ( QKeychain::ReadPasswordJob* readJob = qobject_cast< QKeychain::ReadPasswordJob* >( j ) )
{
if ( readJob->error() == QKeychain::NoError )
{
tDebug() << "QtKeychain readJob for" << readJob->service() << "/"
<< readJob->key() << "finished without errors";
QVariant creds;
QJson::Parser parser;
bool ok;
creds = parser.parse( readJob->textData().toLatin1(), &ok );
QVariantMap map = creds.toMap();
QVariantHash hash;
for ( QVariantMap::const_iterator it = map.constBegin();
it != map.constEnd(); ++it )
{
hash.insert( it.key(), it.value() );
}
creds = QVariant( hash );
if ( !ok || creds.toHash().isEmpty() )
{
creds = QVariant( readJob->textData() );
}
m_credentials.insert( CredentialsStorageKey( readJob->service(), readJob->key() ), creds );
}
else
{
tDebug() << "QtKeychain readJob for" << readJob->service() << "/" << readJob->key() << "finished with error:" << j->error() << j->errorString();
}
m_readJobs[ readJob->service() ].removeOne( readJob );
if ( m_readJobs[ readJob->service() ].isEmpty() )
{
emit serviceReady( readJob->service() );
}
}
else if ( QKeychain::WritePasswordJob* writeJob = qobject_cast< QKeychain::WritePasswordJob* >( j ) )
{
tLog() << Q_FUNC_INFO << "QtKeychain writeJob for" << writeJob->service() << "/" << writeJob->key() << "finished"
<< ( ( j->error() == QKeychain::NoError ) ? "without error" : j->errorString() );
}
else if ( QKeychain::DeletePasswordJob* deleteJob = qobject_cast< QKeychain::DeletePasswordJob* >( j ) )
{
tLog() << Q_FUNC_INFO << "QtKeychain deleteJob for" << deleteJob->service() << "/" << deleteJob->key() << "finished"
<< ( ( j->error() == QKeychain::NoError ) ? "without error" : j->errorString() );
}
j->deleteLater();
}
SerialPortEnumerator::SerialPortEnumerator()
{
connect(&m_refreshTimer, SIGNAL(timeout()), this, SLOT(refresh()));
m_refreshTimer.start(1000);
QVariant cfg = sConfig.get(CFG_VARIANT_SERIAL_CONNECTIONS);
if(cfg.type() == QVariant::Hash)
m_connCfg = cfg.toHash();
}
bool keyedObjectContains(const QVariant &in, const QString &name)
{
if(in.type() == QVariant::Hash)
return in.toHash().contains(name);
else if(in.type() == QVariant::Map)
return in.toMap().contains(name);
else
return false;
}
QVariant keyedObjectGetValue(const QVariant &in, const QString &name)
{
if(in.type() == QVariant::Hash)
return in.toHash().value(name);
else if(in.type() == QVariant::Map)
return in.toMap().value(name);
else
return QVariant();
}
bool keyedObjectIsEmpty(const QVariant &in)
{
if(in.type() == QVariant::Hash)
return in.toHash().isEmpty();
else if(in.type() == QVariant::Map)
return in.toMap().isEmpty();
else
return true;
}
void lua::push_qvariant(lua_State* const state, const QVariant& value)
{
switch (value.userType()) {
case QVariant::Invalid:
lua::push(state, lua::value::nil);
break;
case QVariant::Bool:
lua::push(state, value.toBool());
break;
case QVariant::Char:
lua::push(state, value.toChar());
break;
case QVariant::Int:
{
lua::push(state, value.toInt());
break;
}
case QVariant::Double:
case QVariant::UInt:
lua::push(state, value.toDouble());
break;
case QVariant::String:
lua::push(state, value.toString());
break;
case QVariant::Hash:
{
auto hash = value.toHash();
auto table = lua::push(state, lua::value::table);
for (auto i = hash.begin(); i != hash.end(); ++i) {
lua::table::set(table, i.key(), i.value());
}
break;
}
case QVariant::StringList:
{
auto list = value.toStringList();
auto table = lua::push(state, lua::value::table);
for (int i = 0; i < list.size(); ++i) {
lua::table::set(table, i + 1, list[i]);
}
break;
}
default:
{
auto converter = qvariant_push_handler.find(value.userType());
if (converter != qvariant_push_handler.end()) {
converter->second(state, value);
} else {
throw std::logic_error(std::string("No handler exists to push QVariant type: ") + value.typeName());
}
}
}
}
//FIXME: why to lower case?
void setOptionsToDict(const QVariant& opt, AVDictionary** dict)
{
if (!opt.isValid())
return;
if (opt.type() == QVariant::Map) {
QVariantMap options(opt.toMap());
if (options.isEmpty())
return;
QMapIterator<QString, QVariant> i(options);
while (i.hasNext()) {
i.next();
const QVariant::Type vt = i.value().type();
if (vt == QVariant::Map)
continue;
const QByteArray key(i.key().toUtf8());
switch (vt) {
case QVariant::Bool: {
// QVariant.toByteArray(): "true" or "false", can not recognized by avcodec
av_dict_set(dict, key.constData(), QByteArray::number(i.value().toInt()), 0);
}
break;
default:
// key and value are in lower case
av_dict_set(dict, i.key().toUtf8().constData(), i.value().toByteArray().constData(), 0);
break;
}
qDebug("dict: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
return;
}
QVariantHash options(opt.toHash());
if (options.isEmpty())
return;
QHashIterator<QString, QVariant> i(options);
while (i.hasNext()) {
i.next();
const QVariant::Type vt = i.value().type();
if (vt == QVariant::Hash)
continue;
const QByteArray key(i.key().toUtf8());
switch (vt) {
case QVariant::Bool: {
// QVariant.toByteArray(): "true" or "false", can not recognized by avcodec
av_dict_set(dict, key.constData(), QByteArray::number(i.value().toInt()), 0);
}
break;
default:
// key and value are in lower case
av_dict_set(dict, i.key().toUtf8().constData(), i.value().toByteArray().constData(), 0);
break;
}
qDebug("dict: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
}
QVariant Session::value(Cutelyst::Context *c, const QString &key, const QVariant &defaultValue)
{
QVariant session = c->property(SESSION_VALUES);
if (session.isNull()) {
session = SessionPrivate::loadSession(c);
if (session.isNull()) {
return defaultValue;
}
}
return session.toHash().value(key, defaultValue);
}
QVariant SessionPrivate::loadSession(Context *c)
{
QVariant ret;
const QVariant property = c->property(SESSION_VALUES);
if (!property.isNull()) {
ret = property.toHash();
return ret;
}
static Session *session = c->plugin<Session*>();
if (!session) {
qCCritical(C_SESSION) << "Session plugin not registered";
return ret;
}
const QString sid = Session::id(c);
if (!loadSessionExpires(session, c, sid).isNull()) {
if (SessionPrivate::validateSessionId(sid)) {
const QVariantHash sessionData = session->d_ptr->store->getSessionData(c, sid, QStringLiteral("session")).toHash();
c->setProperty(SESSION_VALUES, sessionData);
if (session->d_ptr->verifyAddress &&
sessionData.contains(QStringLiteral("__address")) &&
sessionData.value(QStringLiteral("__address")).toString() != c->request()->address().toString()) {
qCWarning(C_SESSION) << "Deleting session" << sid << "due to address mismatch:"
<< sessionData.value(QStringLiteral("__address")).toString()
<< "!="
<< c->request()->address().toString();
deleteSession(session, c, QStringLiteral("address mismatch"));
return ret;
}
if (session->d_ptr->verifyUserAgent &&
sessionData.contains(QStringLiteral("__user_agent")) &&
sessionData.value(QStringLiteral("__user_agent")).toString() != c->request()->userAgent()) {
qCWarning(C_SESSION) << "Deleting session" << sid << "due to user agent mismatch:"
<< sessionData.value(QStringLiteral("__user_agent")).toString()
<< "!="
<< c->request()->userAgent();
deleteSession(session, c, QStringLiteral("user agent mismatch"));
return ret;
}
qCDebug(C_SESSION) << "Restored session" << sid;
ret = sessionData;
}
}
return ret;
}
void FormGenRecordComposition::setVaidatedValueImpl(const QVariant &val)
{
mUpdating = UpdatingState;
const QVariantHash map = val.toHash();
for( auto it = map.cbegin(); it != map.cend(); ++it )
mElements.at(mTagIndexMap.value(it.key())).element->setValidatedValue(it.value());
if( mUpdating == UpdatingWithChangeState )
emit valueChanged();
mUpdating = NotUpdatingState;
}
void XmlWriter::writeVariant( QXmlStreamWriter &stream, const QVariant &value )
{
ASSERT_LIMITED_VARIANT( value );
if( value.isNull() || value.type() == QVariant::Invalid ) {
stream.writeEmptyElement( "nil" );
} else if( value.type() == QVariant::Bool ) {
stream.writeTextElement( "boolean", value.toBool() ? "true" : "false" );
} else if( value.type() == QVariant::ByteArray ) {
stream.writeTextElement( "base64", value.toByteArray().toBase64() );
} else if( value.type() == QVariant::Color ) {
writeColor( stream, value.value<QColor>() );
} else if( value.type() == QVariant::Date ) {
stream.writeTextElement( "date", value.toDate().toString( Qt::ISODate ) );
} else if( value.type() == QVariant::DateTime ) {
stream.writeTextElement( "datetime", value.toDateTime().toString( Qt::ISODate ) );
} else if( value.type() == QVariant::Double ) {
stream.writeTextElement( "double", QString::number( value.toDouble() ) );
} else if( value.type() == QVariant::Hash ) {
QHash<QString, QVariant> hash = value.toHash();
QHashIterator<QString, QVariant> it( hash );
stream.writeStartElement( "map" );
stream.writeAttribute( "type", "hash" );
while( it.hasNext() ) {
it.next();
stream.writeStartElement( "item" );
stream.writeTextElement( "key", it.key() );
stream.writeStartElement( "value" );
writeVariant( stream, it.value() );
stream.writeEndElement(); // value
stream.writeEndElement(); // item
}
stream.writeEndElement();
} else if( value.type() == QVariant::Image ) {
QByteArray ba;
QBuffer buffer( &ba );
buffer.open( QIODevice::WriteOnly );
value.value<QImage>().save( &buffer, "PNG" );
buffer.close();
stream.writeTextElement( "image", ba.toBase64() );
} else if( value.type() == QVariant::Int ) {
stream.writeTextElement( "int", QString::number( value.toInt() ) );
} else if( value.type() == QVariant::List ) {
stream.writeStartElement( "list" );
const QVariantList list = value.toList();
foreach( const QVariant & var, list ) {
writeVariant( stream, var );
}
void setOptionsToFFmpegObj(const QVariant& opt, void* obj)
{
if (!opt.isValid())
return;
AVClass *c = obj ? *(AVClass**)obj : 0;
if (c)
qDebug() << QStringLiteral("%1.%2 options:").arg(QLatin1String(c->class_name)).arg(QLatin1String(c->item_name(obj)));
else
qDebug() << "options:";
if (opt.type() == QVariant::Map) {
QVariantMap options(opt.toMap());
if (options.isEmpty())
return;
QMapIterator<QString, QVariant> i(options);
while (i.hasNext()) {
i.next();
const QVariant::Type vt = i.value().type();
if (vt == QVariant::Map)
continue;
const QByteArray key(i.key().toUtf8());
qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
if (vt == QVariant::Int || vt == QVariant::UInt || vt == QVariant::Bool) {
// QVariant.toByteArray(): "true" or "false", can not recognized by avcodec
av_opt_set_int(obj, key.constData(), i.value().toInt(), AV_OPT_SEARCH_CHILDREN);
} else if (vt == QVariant::LongLong || vt == QVariant::ULongLong) {
av_opt_set_int(obj, key.constData(), i.value().toLongLong(), AV_OPT_SEARCH_CHILDREN);
} else if (vt == QVariant::Double) {
av_opt_set_double(obj, key.constData(), i.value().toDouble(), AV_OPT_SEARCH_CHILDREN);
}
}
return;
}
QVariantHash options(opt.toHash());
if (options.isEmpty())
return;
QHashIterator<QString, QVariant> i(options);
while (i.hasNext()) {
i.next();
const QVariant::Type vt = i.value().type();
if (vt == QVariant::Hash)
continue;
const QByteArray key(i.key().toUtf8());
qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
if (vt == QVariant::Int || vt == QVariant::UInt || vt == QVariant::Bool) {
av_opt_set_int(obj, key.constData(), i.value().toInt(), AV_OPT_SEARCH_CHILDREN);
} else if (vt == QVariant::LongLong || vt == QVariant::ULongLong) {
av_opt_set_int(obj, key.constData(), i.value().toLongLong(), AV_OPT_SEARCH_CHILDREN);
}
}
}
QVariant getChild(const QVariant &in, const QString &parentName, const QString &childName, bool required, bool *ok, QString *errorMessage)
{
if(!isKeyedObject(in))
{
QString pn = !parentName.isEmpty() ? parentName : QString("value");
setError(ok, errorMessage, QString("%1 is not an object").arg(pn));
return QVariant();
}
QString pn = !parentName.isEmpty() ? parentName : QString("object");
QVariant v;
if(in.type() == QVariant::Hash)
{
QVariantHash h = in.toHash();
if(!h.contains(childName))
{
if(required)
setError(ok, errorMessage, QString("%1 does not contain '%2'").arg(pn, childName));
else
setSuccess(ok, errorMessage);
return QVariant();
}
v = h[childName];
}
else // Map
{
QVariantMap m = in.toMap();
if(!m.contains(childName))
{
if(required)
setError(ok, errorMessage, QString("%1 does not contain '%2'").arg(pn, childName));
else
setSuccess(ok, errorMessage);
return QVariant();
}
v = m[childName];
}
setSuccess(ok, errorMessage);
return v;
}
bool QtVariantContext::isFalse(const QString& key) const
{
QVariant value = this->value(key);
switch (value.userType()) {
case QVariant::Bool:
return !value.toBool();
case QVariant::List:
return value.toList().isEmpty();
case QVariant::Hash:
return value.toHash().isEmpty();
case QVariant::Map:
return value.toMap().isEmpty();
default:
return value.toString().isEmpty();
}
}
void AVDecoder::setOptions(const QVariantHash &dict)
{
DPTR_D(AVDecoder);
d.options = dict;
// if dict is empty, can not return here, default options will be set for AVCodecContext
// apply to AVCodecContext
d.applyOptionsForContext();
/* set AVDecoder meta properties.
* we do not check whether the property exists thus we can set dynamic properties.
*/
if (dict.isEmpty())
return;
if (name() == "avcodec")
return;
QVariant opt;
if (dict.contains(name()))
opt = dict.value(name());
else if (dict.contains(name().toLower()))
opt = dict.value(name().toLower());
else
return; // TODO: set property if no name() key found?
if (opt.type() == QVariant::Hash) {
QVariantHash property_dict(opt.toHash());
if (property_dict.isEmpty())
return;
QHashIterator<QString, QVariant> i(property_dict);
while (i.hasNext()) {
i.next();
if (i.value().type() == QVariant::Hash) // for example "vaapi": {...}
continue;
setProperty(i.key().toUtf8().constData(), i.value());
qDebug("decoder meta property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
} else if (opt.type() == QVariant::Map) {
QVariantMap property_dict(opt.toMap());
if (property_dict.isEmpty())
return;
QMapIterator<QString, QVariant> i(property_dict);
while (i.hasNext()) {
i.next();
if (i.value().type() == QVariant::Map) // for example "vaapi": {...}
continue;
setProperty(i.key().toUtf8().constData(), i.value());
qDebug("decoder meta property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
}
}
