available_settings.cpp

Go to the documentation of this file.

#include <QString>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QMessageBox>
#include <cstring>
#include "available_settings.hpp"
#include "utils/string_view_utils.hpp"
 
#include <iostream>
#include <map>
#include <algorithm>
 
static bool vectorContains(const std::vector<std::string> &v, const std::string & s){
        for(unsigned i = 0; i < v.size(); i++){
                if(v[i] == s)
                        return true;
        }
        return false;
}
 
const char *settingTypeToStr(SettingType type){
#define X(type, str) case type: return str;
        switch(type){
        SETTING_TYPE_LIST
        case SETTING_TYPE_COUNT: return "";
        }
#undef X
 
        abort(); //Should be unreachable
}
 
SettingType strToSettingType(std::string_view sv){
#define X(type, str) if(sv == str) return type; else
        SETTING_TYPE_LIST{
                return SETTING_TYPE_UNKNOWN;
        }
#undef X
 
        abort(); //Should be unreachable
}
 
void AvailableSettings::queryProcessLine(std::string_view line){
        constexpr std::string_view module_cap_prefix = "[cap][";
        if(sv_is_prefix(line, module_cap_prefix)){
                line.remove_prefix(module_cap_prefix.size());
                if(line.empty())
                        return;
 
                auto module_type = tokenize(line, ']');
                auto module_name = sv_trim_whitespace(tokenize(line, ']'));
 
                if(!module_type.empty() && !module_name.empty())
                        available[strToSettingType(module_type)].emplace_back(module_name);
 
                return;
        }
 
        constexpr std::string_view devStr = "[capability][device]";
        constexpr std::string_view codecStr = "[capability][video_compress]";
        constexpr std::string_view endMarkerStr = "[capability][end]";
 
        if(sv_is_prefix(line, devStr)){
                line.remove_prefix(devStr.size());
                queryDevice(line);
        } else if(sv_is_prefix(line, codecStr)){
                line.remove_prefix(codecStr.size());
                queryVideoCompress(line);
        } else if(sv_is_prefix(line, endMarkerStr)){
                endMarkerFound = true;
        }
}
 
void AvailableSettings::parseStateVersion(std::string_view line){
        int ver = 0;
        std::string_view verStr = "[capability][start] version ";
 
        if(sv_is_prefix(line, verStr)){
                line.remove_prefix(verStr.size());
                parse_num(line, ver);
 
                const int expectedVersion = 4;
                if(ver != expectedVersion){
                        QMessageBox msgBox;
                        QString msg = "Capabilities start marker with expected version not found"
                                " in ug output.";
                        if(ver != 0)
                                msg += " Version found: " + QString::number(ver);
                        msgBox.setText(msg);
                        msgBox.setIcon(QMessageBox::Critical);
                        msgBox.exec();
                        parseFunc = nullptr;
                } else {
                        parseFunc = &AvailableSettings::queryProcessLine;
                }
        }
}
 
void AvailableSettings::queryBeginPass(){
        endMarkerFound = false;
        parseFunc = &AvailableSettings::parseStateVersion;
}
 
void AvailableSettings::queryBegin(){
        for(auto& i : available){
                i.clear();
        }
        for(auto& i : devices){
                i.clear();
        }
        videoCompressModules.clear();
        videoCompressCodecs.clear();
        videoCompressModules.emplace_back(CompressModule{"", {}, });
        videoCompressCodecs.emplace_back(Codec{"None", "", {Encoder{"default", ""}}, 0});
 
        queryBeginPass();
}
 
void AvailableSettings::queryEnd(){
        std::sort(videoCompressCodecs.begin(), videoCompressCodecs.end(),
                        [](const Codec& a, const Codec& b){
                                return a.priority < b.priority;
                        });
}
 
void AvailableSettings::queryLine(std::string_view line){
        if(!parseFunc || (!sv_is_prefix(line, "[cap]") && !sv_is_prefix(line, "[capability]")))
                return;
 
        (this->*parseFunc)(line);
}
 
static void maybeWriteString (const QJsonObject& obj,
                const char *key,
                std::string& result)
{
                if(obj.contains(key) && obj[key].isString()){
                        result = obj[key].toString().toStdString();
                }
}
 
std::vector<CapabOpt> parseCapabOpts(const QJsonObject& obj){
        std::vector<CapabOpt> opts;
 
        if(obj.contains("options") && obj["options"].isArray()){
                for(const QJsonValue &val : obj["options"].toArray()){
                        QJsonObject optJson = val.toObject();
 
                        CapabOpt capabOpt;
                        maybeWriteString(optJson, "display_name", capabOpt.displayName);
                        maybeWriteString(optJson, "display_desc", capabOpt.displayDesc);
                        maybeWriteString(optJson, "placeholder_text", capabOpt.placeholder);
                        maybeWriteString(optJson, "key", capabOpt.key);
                        maybeWriteString(optJson, "opt_str", capabOpt.optStr);
                        if(optJson.contains("is_boolean") && optJson["is_boolean"].isString()){
                                capabOpt.booleanOpt = optJson["is_boolean"].toString() == "t";
                        }
 
                        opts.emplace_back(std::move(capabOpt));
                }
        }
 
        return opts;
}
 
void AvailableSettings::queryVideoCompress(std::string_view line){
        QJsonDocument doc = QJsonDocument::fromJson(QByteArray::fromRawData(line.data(), line.size()));
        if(!doc.isObject())
                return;
 
        CompressModule compMod;
        QJsonObject obj = doc.object();
        maybeWriteString(obj, "name", compMod.name);
 
 
        compMod.opts = parseCapabOpts(obj);
 
        if(obj.contains("codecs") && obj["codecs"].isArray()){
                for(const QJsonValue &val : obj["codecs"].toArray()){
                        QJsonObject codecJson = val.toObject();
 
                        Codec codec;
                        maybeWriteString(codecJson, "name", codec.name);
                        codec.module_name = compMod.name;
                        if(codecJson.contains("priority") && codecJson["priority"].isDouble()){
                                codec.priority = codecJson["priority"].toInt();
                        }
 
                        if(codecJson.contains("encoders") && codecJson["encoders"].isArray()){
                                for(const QJsonValue &val : codecJson["encoders"].toArray()){
                                        QJsonObject encoderJson = val.toObject();
 
                                        Encoder encoder;
                                        maybeWriteString(encoderJson, "name", encoder.name);
                                        maybeWriteString(encoderJson, "opt_str", encoder.optStr);
 
                                        codec.encoders.emplace_back(std::move(encoder));
                                }
                        }
 
                        if(codec.encoders.empty()){
                                codec.encoders.emplace_back(Encoder{"default", ""});
                        }
 
                        videoCompressCodecs.emplace_back(std::move(codec));
                }
        }
 
        videoCompressModules.emplace_back(std::move(compMod));
}
 
void AvailableSettings::queryDevice(std::string_view line){
        static std::map<std::string, SettingType> settingTypeMap = {
                {"video_cap", VIDEO_SRC},
                {"video_disp", VIDEO_DISPLAY},
                {"audio_play", AUDIO_PLAYBACK},
                {"audio_cap", AUDIO_SRC},
        };
 
        QJsonDocument doc = QJsonDocument::fromJson(QByteArray::fromRawData(line.data(), line.size()));
        if(!doc.isObject())
                return;
 
        Device dev;
        QJsonObject obj = doc.object();
        maybeWriteString(obj, "name", dev.name);
        maybeWriteString(obj, "module", dev.type);
        maybeWriteString(obj, "device", dev.deviceOpt);
 
        if(obj.contains("extra") && obj["extra"].isObject()){
                const auto& extraObj = obj["extra"].toObject();
                for(auto it = extraObj.constBegin(); it != extraObj.constEnd(); it++){
                        if(it.value().isString()){
                                dev.extra[it.key().toStdString()] = it.value().toString().toStdString();
                        }
                }
        }
 
        if(obj.contains("modes") && obj["modes"].isArray()){
                for(const QJsonValue &val : obj["modes"].toArray()){
                        if(val.isObject()){
                                QJsonObject modeJson = val.toObject();
 
                                DeviceMode mode;
 
                                maybeWriteString(modeJson, "name", mode.name);
 
                                if(modeJson.contains("opts") && modeJson["opts"].isObject()){
                                        QJsonObject modeOpts = modeJson["opts"].toObject();
                                        for(const QString &key : modeOpts.keys()){
                                                if(modeOpts[key].isString()){
                                                        mode.opts.push_back(SettingVal{key.toStdString(),
                                                                        modeOpts[key].toString().toStdString()});
                                                }
                                        }
                                        dev.modes.push_back(std::move(mode));
                                }
                        }
                }
        }
 
        dev.opts = parseCapabOpts(obj);
 
        SettingType settingType = SETTING_TYPE_UNKNOWN;
        if(obj.contains("purpose") && obj["purpose"].isString()){
                settingType = settingTypeMap[obj["purpose"].toString().toStdString()];
        }
        dev.settingType = settingType;
        devices[settingType].push_back(std::move(dev));
}
 
bool AvailableSettings::isAvailable(const std::string &name, SettingType type) const{
        return vectorContains(available[type], name);
}
 
const std::vector<std::string>& AvailableSettings::getAvailableSettings(SettingType type) const{
        return available[type];
}
 
const std::vector<Device>& AvailableSettings::getDevices(SettingType type) const{
        return devices[type];
}