settings.cpp

Go to the documentation of this file.

#include <iostream>
#include <algorithm>
#include <random>
#include "settings.hpp"
#include "available_settings.hpp"
 
Option::Callback::Callback(fcn_type func_ptr, void *opaque) :
        func_ptr(func_ptr),
        opaque(opaque)
{
 
}
 
void Option::Callback::operator()(Option& opt, bool suboption) const{
        func_ptr(opt, suboption, opaque);
}
 
bool Option::Callback::operator==(const Callback& o) const{
        return func_ptr == o.func_ptr && opaque == o.opaque;
}
 
std::string Option::getName() const{
        return name;
}
 
std::string Option::getValue() const{
        return value;
}
 
std::string Option::getParam() const{
        return param;
}
 
std::string Option::getSubVals() const{
        std::string out;
 
        for(const auto &sub : suboptions){
                if(sub.first.empty() || sub.first == value){
                        out += sub.second->getLaunchOption();
                }
        }
 
        return out;
}
 
std::string Option::getLaunchOption() const{
        if(type == OptType::BoolOpt){
                return enabled ? param : "";
        }
 
        std::string out = "";
        if(enabled && !value.empty() && type != OptType::SilentOpt)
                out = param + value;
 
        out += getSubVals();
 
        return out;
}
 
void Option::changed(){
        for(const auto &callback : onChangeCallbacks){
                callback(*this, false);
        }
}
 
void Option::suboptionChanged(Option &opt, bool, void *opaque){
        Option *obj = static_cast<Option *>(opaque);
        for(const auto &callback : obj->onChangeCallbacks){
                callback(opt, true);
        }
}
 
void Option::setValue(const std::string &val, bool suppressCallback){
        value = val;
 
        if(type == OptType::BoolOpt){
                enabled = val == "t";
        } else {
                enabled = !val.empty();
        }
 
        if(!suppressCallback)
                changed();
}
 
void Option::setDefaultValue(const std::string &val){
        defaultValue = val;
}
 
void Option::setEnabled(bool enable, bool suppressCallback){
        enabled = enable;
        if(!suppressCallback)
                changed();
}
 
void Option::addSuboption(Option *sub, const std::string &limit){
        auto pair = std::make_pair(limit, sub);
        auto it = std::find(suboptions.begin(), suboptions.end(), pair);
 
        if(it != suboptions.end())
                return;
 
        sub->addOnChangeCallback(Callback(&Option::suboptionChanged, this));
        suboptions.push_back(pair);
}
 
void Option::addOnChangeCallback(Callback callback){
        onChangeCallbacks.push_back(callback);
}
 
void Option::removeOnChangeCallback(const Callback& callback){
        auto it = std::find(onChangeCallbacks.begin(), onChangeCallbacks.end(), callback);
 
        if(it == onChangeCallbacks.end()){
                std::cout << "Attempted to remove non-existent callback "
                        << name
                        << std::endl;
                return;
        }
 
#ifdef DEBUG
        std::cout << "Removing callback "
                << name
                << std::endl;
#endif
        onChangeCallbacks.erase(it);
}
 
Settings *Option::getSettings(){
        return settings;
}
 
#ifdef DEBUG
static void test_callback(Option &opt, bool, void *){
        std::cout << "Callback: " << opt.getName()
                << ": " << opt.getValue()
                << " (" << opt.isEnabled() << ")" << std::endl;
}
#endif
 
static void fec_builder_callback(Option &opt, bool subopt, void *){
        if(!subopt)
                return;
 
        Settings *settings = opt.getSettings();
        Option &fecOpt = settings->getOption("network.fec");
        bool enabled = settings->getOption("network.fec.enabled").isEnabled();
 
        std::string type = settings->getOption("network.fec.type").getValue();
 
        if(type.empty() || !enabled){
                fecOpt.setValue("");
        } else if(type == "mult"){
                fecOpt.setValue("mult:" + settings->getOption("network.fec.mult.factor").getValue());
        } else if(type == "rs"){
                fecOpt.setValue("rs:"
                                + settings->getOption("network.fec.rs.k").getValue()
                                + ":" + settings->getOption("network.fec.rs.n").getValue());
        } else if(type == "ldgm"){
                fecOpt.setValue("ldgm:"
                                + settings->getOption("network.fec.ldgm.k").getValue()
                                + ":" + settings->getOption("network.fec.ldgm.m").getValue()
                                + ":" + settings->getOption("network.fec.ldgm.c").getValue()
                                + settings->getOption("network.fec.ldgm.device").getParam()
                                + settings->getOption("network.fec.ldgm.device").getValue());
        }
 
 
}
 
static void fec_auto_callback(Option &opt, bool /*subopt*/, void *){
        Settings *settings = opt.getSettings();
 
        if(!settings->getOption("network.fec.auto").isEnabled())
                return;
 
        Option &fecOpt = settings->getOption("network.fec.type");
        const std::string &video_compress = settings->getOption("video.compress").getValue();
 
        if(video_compress == ""){
                fecOpt.setValue("");
        } else if(video_compress == "jpeg"){
                fecOpt.setValue("ldgm");
        } else if(video_compress == "libavcodec"
                        && settings->getOption("video.compress.libavcodec.codec").getValue() == "MJPEG"){
                fecOpt.setValue("ldgm");
        } else {
                fecOpt.setValue("rs");
        }
}
 
const static struct{
        const char *name;
        Option::OptType type;
        const char *param;
        const char *defaultVal;
        bool enabled;
        const char *parent;
        const char *limit;
} optionList[] = {
        {"extraOpts", Option::StringOpt, "", "", false, "", ""},
        {"video.source", Option::StringOpt, " -t ", "", false, "", ""},
        {"video.source.embeddedAudioAvailable", Option::SilentOpt, "", "", false, "", ""},
        {"testcard.width", Option::StringOpt, ":", "", false, "video.source", "testcard"},
        {"testcard.height", Option::StringOpt, ":", "", false, "video.source", "testcard"},
        {"testcard.fps", Option::StringOpt, ":", "", false, "video.source", "testcard"},
        {"testcard.format", Option::StringOpt, ":", "", false, "video.source", "testcard"},
        {"screen.fps", Option::StringOpt, ":fps=", "", false, "video.source", "screen"},
        {"v4l2.codec", Option::StringOpt, ":codec=", "", false, "video.source", "v4l2"},
        {"v4l2.size", Option::StringOpt, ":size=", "", false, "video.source", "v4l2"},
        {"v4l2.tpf", Option::StringOpt, ":tpf=", "", false, "video.source", "v4l2"},
        {"v4l2.force_rgb", Option::BoolOpt, ":convert=RGB", "t", true, "video.source", "v4l2"},
        {"dshow.mode", Option::StringOpt, ":mode=", "", false, "video.source", "dshow"},
        {"dshow.force_rgb", Option::BoolOpt, ":RGB", "t", true, "video.source", "dshow"},
        {"avfoundation.mode", Option::StringOpt, ":mode=", "", false, "video.source", "avfoundation"},
        {"avfoundation.fps", Option::StringOpt, ":fps=", "", false, "video.source", "avfoundation"},
        {"decklink.modeOpt", Option::StringOpt, ":", "", false, "video.source", "decklink"},
        {"video.display", Option::StringOpt, " -d ", "", false, "", ""},
        {"video.display.embeddedAudioAvailable", Option::SilentOpt, "", "", false, "", ""},
        {"video.compress", Option::StringOpt, " -c ", "", false, "", ""},
        {"audio.source", Option::StringOpt, " -s ", "", false, "", ""},
        {"audio.source.channels", Option::StringOpt, " --audio-capture-format channels=", "", false, "", ""},
        {"audio.playback", Option::StringOpt, " -r ", "", false, "", ""},
        {"audio.compress", Option::StringOpt, " --audio-codec ", "", false, "", ""},
        {"bitrate", Option::StringOpt, ":bitrate=", "", false, "audio.compress", ""},
        {"network.destination", Option::StringOpt, " ", "", false, "", ""},
        {"network.port", Option::StringOpt, " -P ", "5004", false, "", ""},
        {"network.control_port", Option::StringOpt, " --control-port ", "8888", true, "", ""},
        {"network.control_port.random", Option::BoolOpt, "", "", true, "", ""},
        {"network.fec", Option::StringOpt, " -f ", "", false, "", ""},
        {"type", Option::SilentOpt, "", "", false, "network.fec", ""},
        {"enabled", Option::BoolOpt, "", "f", false, "network.fec", ""},
        {"mult.factor", Option::SilentOpt, ":", "2", false, "network.fec", ""},
        {"ldgm.k", Option::SilentOpt, ":", "256", false, "network.fec", ""},
        {"ldgm.m", Option::SilentOpt, ":", "192", false, "network.fec", ""},
        {"ldgm.c", Option::SilentOpt, ":", "5", false, "network.fec", ""},
        {"ldgm.device", Option::SilentOpt, " --param ldgm-device=", "CPU", false, "network.fec", ""},
        {"rs.k", Option::SilentOpt, ":", "200", false, "network.fec", ""},
        {"rs.n", Option::SilentOpt, "", "220", false, "network.fec", ""},
        {"network.fec.auto", Option::BoolOpt, "", "t", true, "", ""},
        {"decode.hwaccel", Option::BoolOpt, " --param use-hw-accel", "f", false, "", ""},
        {"advanced", Option::BoolOpt, "", "f", false, "", ""},
        {"preview", Option::BoolOpt, "", "t", true, "", ""},
        {"vuMeter", Option::BoolOpt, "", "t", true, "", ""},
        {"errors_fatal", Option::BoolOpt, " --param errors-fatal", "t", true, "", ""},
        {"encryption", Option::StringOpt, " --encryption ", "", false, "", ""},
};
 
const struct {
        const char *name;
        Option::Callback::fcn_type callback;
} optionCallbacks[] = {
        {"network.fec", fec_builder_callback},
        {"video.compress", fec_auto_callback},
        {"network.fec.auto", fec_auto_callback},
};
 
Settings::Settings() : dummy(this){
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> bounds(0, ('9' - '0') + ('z' - 'a'));
        for(int i = 0; i < 8; i++){
                int rand = bounds(gen);
                if(rand <= 9)
                        sessRndKey += '0' + rand;
                else
                        sessRndKey += 'a' + (rand - 9);
        }
 
        for(const auto &i : optionList){
                auto &opt = addOption(i.name,
                                i.type,
                                i.param,
                                i.defaultVal,
                                i.enabled,
                                i.parent,
                                i.limit);
#ifdef DEBUG
                if(!i.parent[0])
                        opt.addOnChangeCallback(Option::Callback(test_callback, nullptr));
#endif
                (void) opt; //suppress unused warning
        }
 
        for(const auto &i : optionCallbacks){
                getOption(i.name).addOnChangeCallback(Option::Callback(i.callback, nullptr));
        }
 
        std::cout << getLaunchParams() << std::endl;
}
 
std::string Settings::getControlPort() const{
        if(getOption("network.control_port.random").isEnabled())
                return "0";
 
        return getOption("network.control_port").getValue();
}
 
std::string Settings::getLaunchParams() const{
        std::string out;
 
        out += getOption("extraOpts").getLaunchOption();
 
        if(getOption("preview").isEnabled()){
                out += " --capture-filter preview";
                out += ":key=" + getSessRndKey();
        }
 
        out += getOption("video.source").getLaunchOption();
        out += getOption("video.compress").getLaunchOption();
        const auto &dispOpt = getOption("video.display");
        if(dispOpt.isEnabled()){
                if(getOption("preview").isEnabled()){
                        out += dispOpt.getParam();
                        out += "multiplier:" + dispOpt.getValue() + dispOpt.getSubVals();
                        out += "#preview";
                        out += ":key=" + getSessRndKey();
                } else {
                        out += getOption("video.display").getLaunchOption();
                }
        } else {
                if(getOption("preview").isEnabled()){
                        out += dispOpt.getParam();
                        out += "preview";
                        out += ":key=" + getSessRndKey();
                }
        }
 
        out += " --audio-filter controlport_stats";
        out += getOption("audio.source").getLaunchOption();
        out += getOption("audio.source.channels").getLaunchOption();
        out += getOption("audio.compress").getLaunchOption();
        std::string audioPlay = getOption("audio.playback").getLaunchOption();
        if(audioPlay.empty() && getOption("preview").isEnabled()){
                audioPlay = " -r dummy";
        }
        out += audioPlay;
        out += getOption("network.fec").getLaunchOption();
        out += getOption("encryption").getLaunchOption();
        out += getOption("network.port").getLaunchOption();
        out += getOption("network.control_port").getParam();
        out += getControlPort();
        out += getOption("network.destination").getLaunchOption();
        out += getOption("decode.hwaccel").getLaunchOption();
        out += getOption("errors_fatal").getLaunchOption();
        return out;
}
 
std::string Settings::getPreviewParams() const{
        std::string out;
 
        out += getOption("extraOpts").getLaunchOption();
 
        out += " --capture-filter preview";
        out += ":key=" + getSessRndKey();
        out += ",every:0";
        out += getOption("video.source").getLaunchOption();
        out += " -d preview";
        out += ":key=" + getSessRndKey();
        out += " --audio-filter controlport_stats#discard";
        out += getOption("audio.source").getLaunchOption();
        out += getOption("audio.source.channels").getLaunchOption();
        out += " -r dummy";
        out += getOption("network.control_port").getParam();
        out += getControlPort();
        out += getOption("encryption").getLaunchOption();
 
        return out;
}
 
Option& Settings::getOption(const std::string &opt){
        auto search = options.find(opt);
 
        if(search == options.end()){
                std::unique_ptr<Option> newOption(new Option(this, opt));
                auto p = newOption.get();
                options[opt] = std::move(newOption);
                return *p;
        }
 
        return *search->second;
}
 
const Option& Settings::getOption(const std::string &opt) const{
        auto search = options.find(opt);
 
        if(search == options.end())
                return dummy;
 
        return *search->second;
}
 
const std::map<std::string, std::unique_ptr<Option>>& Settings::getOptionMap() const{
        return options;
}
 
Option& Settings::addOption(std::string name,
                Option::OptType type,
                const std::string &param,
                const std::string &value,
                bool enabled,
                const std::string &parent,
                const std::string &limit)
{
        if(!parent.empty())
                name = parent + "." + name;
 
        auto search = options.find(name);
 
        Option *opt;
 
        if(search == options.end()){
                std::unique_ptr<Option> newOption(new Option(this, name));
                opt = newOption.get();
                options[name] = std::move(newOption);
        } else {
                opt = search->second.get();
        }
 
        opt->setParam(param);
        opt->setType(type);
        opt->setValue(value);
        opt->setDefaultValue(value);
        opt->setEnabled(enabled);
 
        if(!parent.empty()){
                getOption(parent).addSuboption(opt, limit);
        }
 
        return *opt;
}
 
bool Settings::isAdvancedMode(){
        return getOption("advanced").getValue() == "t";
}
 
void Settings::changedAll(){
        for(auto &i : options){
                i.second->changed();
        }
}
 
static void addDevOpt(Settings* settings, const Device& dev, const char *parent){
                settings->addOption(dev.type + ".device",
                                Option::StringOpt,
                                "",
                                "",
                                false,
                                parent,
                                dev.type);
}
 
void Settings::populateDeviceSettings(AvailableSettings *availSettings){
        struct{
                SettingType type;
                const char *optPrefix;
        } devTypes[] = {
                {VIDEO_SRC, "video.source"},
                {VIDEO_DISPLAY, "video.display"},
                {AUDIO_SRC, "audio.source"},
                {AUDIO_PLAYBACK, "audio.playback"},
        };
 
        for(const auto& devType : devTypes){
                for(const auto& dev : availSettings->getDevices(devType.type)){
                        addDevOpt(this, dev, devType.optPrefix);
 
                        for(const auto& devOpt : dev.opts){
                                addOption(dev.deviceOpt + "." + devOpt.key,
                                                devOpt.booleanOpt ? Option::BoolOpt : Option::StringOpt,
                                                devOpt.optStr,
                                                "",
                                                false,
                                                std::string(devType.optPrefix) + "." + dev.type + ".device",
                                                dev.deviceOpt);
                        }
                }
        }
}
 
void Settings::populateVideoCompressSettings(AvailableSettings *availSettings){
        for(const auto& mod : availSettings->getVideoCompressModules()){
                addOption(mod.name + ".codec",
                                Option::SilentOpt,
                                "",
                                "",
                                false,
                                "video.compress",
                                mod.name);
 
                for(const auto& modOption: mod.opts){
                        addOption(mod.name + "." + modOption.key,
                                        modOption.booleanOpt ? Option::BoolOpt : Option::StringOpt,
                                        modOption.optStr,
                                        "",
                                        false,
                                        "video.compress",
                                        mod.name
                                        );
                }
        }
 
        for(const auto& codec : availSettings->getVideoCompressCodecs()){
                std::string optName = "video.compress.";
                optName += codec.module_name;
                optName += ".codec";
 
                addOption(codec.name + ".encoder",
                                Option::StringOpt,
                                "",
                                codec.encoders[0].optStr,
                                true,
                                optName,
                                codec.name);
        }
}
 
void Settings::populateSettingsFromCapabilities(AvailableSettings *availSettings){
        populateDeviceSettings(availSettings);
        populateVideoCompressSettings(availSettings);
}
 
 
 
/* vim: set noexpandtab: */