#include <available_settings.hpp>

Collaboration diagram for AvailableSettings:

Public Member Functions
const std::vector< std::string > &	getAvailableSettings (SettingType type) const

const std::vector< Device > &	getDevices (SettingType type) const

const std::vector< Codec > &	getVideoCompressCodecs () const

const std::vector< CompressModule > &	getVideoCompressModules () const

bool	isAvailable (const std::string &name, SettingType type) const

void	queryBegin ()

void	queryBeginPass ()

void	queryEnd ()

void	queryLine (std::string_view line)

Private Member Functions
void	parseStateVersion (std::string_view line)

void	queryDevice (std::string_view line)

void	queryProcessLine (std::string_view line)

void	queryVideoCompress (std::string_view line)

Private Attributes
std::vector< std::string >	available [SETTING_TYPE_COUNT]

std::vector< Device >	devices [SETTING_TYPE_COUNT]

bool	endMarkerFound = false

void(AvailableSettings::*	parseFunc )(std::string_view str) = nullptr

std::vector< Codec >	videoCompressCodecs

std::vector< CompressModule >	videoCompressModules

Detailed Description

Definition at line 85 of file available_settings.hpp.

Member Function Documentation

◆ getAvailableSettings()

const std::vector< std::string > & AvailableSettings::getAvailableSettings ( SettingType type ) const

Definition at line 276 of file available_settings.cpp.

                                                                                         {
        return available[type];
}

References available, and type.

Referenced by getAudioCompress(), getVideoDisplay(), and getVideoSrc().

◆ getDevices()

const std::vector< Device > & AvailableSettings::getDevices ( SettingType type ) const

Definition at line 280 of file available_settings.cpp.

                                                                            {
        return devices[type];
}

References devices, and type.

Referenced by SettingsUi::buildSettingsDeviceList(), getAudioPlayback(), getAudioSrc(), getVideoDisplay(), getVideoModes(), getVideoSrc(), and Settings::populateDeviceSettings().

◆ getVideoCompressCodecs()

const std::vector< Codec > & AvailableSettings::getVideoCompressCodecs ( ) const

inline

Definition at line 101 of file available_settings.hpp.

                                                               {
                return videoCompressCodecs;
        }

References videoCompressCodecs.

Referenced by SettingsUi::buildSettingsCodecList(), getVideoCompress(), and Settings::populateVideoCompressSettings().

◆ getVideoCompressModules()

const std::vector< CompressModule > & AvailableSettings::getVideoCompressModules ( ) const

inline

Definition at line 97 of file available_settings.hpp.

                                                                         {
                return videoCompressModules;
        }

References videoCompressModules.

Referenced by SettingsUi::buildCodecOptControls(), Settings::populateVideoCompressSettings(), and videoCompressBitrateCallback().

◆ isAvailable()

bool AvailableSettings::isAvailable	(	const std::string &	name,
		SettingType	type ) const

Definition at line 272 of file available_settings.cpp.

                                                                                {
        return vectorContains(available[type], name);
}

References available, name, type, and vectorContains().

Referenced by UltragridWindow::checkPreview().

Here is the call graph for this function:

◆ parseStateVersion()

void AvailableSettings::parseStateVersion ( std::string_view line )

private

Definition at line 74 of file available_settings.cpp.

                                                            {
        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;
                }
        }
}

References parse_num(), parseFunc, queryProcessLine(), and sv_is_prefix().

Referenced by queryBeginPass().

Here is the call graph for this function:

◆ queryBegin()

void AvailableSettings::queryBegin ( )

Definition at line 104 of file available_settings.cpp.

                                  {
        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();
}

References available, devices, queryBeginPass(), videoCompressCodecs, and videoCompressModules.

Referenced by UltragridWindow::launchQuery().

Here is the call graph for this function:

◆ queryBeginPass()

void AvailableSettings::queryBeginPass ( )

Definition at line 99 of file available_settings.cpp.

                                      {
        endMarkerFound = false;
        parseFunc = &AvailableSettings::parseStateVersion;
}

References endMarkerFound, parseFunc, and parseStateVersion().

Referenced by queryBegin().

Here is the call graph for this function:

◆ queryDevice()

void AvailableSettings::queryDevice ( std::string_view line )

private

Definition at line 212 of file available_settings.cpp.

                                                      {
        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));
}

References Device::deviceOpt, devices, doc, Device::extra, key, maybeWriteString(), mode, Device::modes, Device::name, Device::opts, parseCapabOpts(), Device::settingType, Device::type, and val.

Referenced by queryProcessLine().

Here is the call graph for this function:

◆ queryEnd()

void AvailableSettings::queryEnd ( )

Definition at line 119 of file available_settings.cpp.

                                {
        std::sort(videoCompressCodecs.begin(), videoCompressCodecs.end(),
                        [](const Codec& a, const Codec& b){
                                return a.priority < b.priority;
                        });
}

References videoCompressCodecs.

◆ queryLine()

void AvailableSettings::queryLine ( std::string_view line )

Definition at line 126 of file available_settings.cpp.

                                                    {
        if(!parseFunc || (!sv_is_prefix(line, "[cap]") && !sv_is_prefix(line, "[capability]")))
                return;
 
        (this->*parseFunc)(line);
}

References parseFunc, and sv_is_prefix().

Here is the call graph for this function:

◆ queryProcessLine()

void AvailableSettings::queryProcessLine ( std::string_view line )

private

Definition at line 43 of file available_settings.cpp.

                                                           {
        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;
        }
}

References available, endMarkerFound, queryDevice(), queryVideoCompress(), strToSettingType(), sv_is_prefix(), sv_trim_whitespace(), and tokenize().

Referenced by parseStateVersion().

Here is the call graph for this function:

◆ queryVideoCompress()

void AvailableSettings::queryVideoCompress ( std::string_view line )

private

Definition at line 166 of file available_settings.cpp.

                                                             {
        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));
}