static obs_properties_t *chroma_key_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *p = obs_properties_add_list(props,
SETTING_COLOR_TYPE, TEXT_COLOR_TYPE,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(p, obs_module_text("Green"), "green");
obs_property_list_add_string(p, obs_module_text("Blue"), "blue");
obs_property_list_add_string(p, obs_module_text("Magenta"), "magenta");
obs_property_list_add_string(p, obs_module_text("Custom"), "custom");
obs_property_set_modified_callback(p, key_type_changed);
obs_properties_add_color(props, SETTING_KEY_COLOR, TEXT_KEY_COLOR);
obs_properties_add_int_slider(props, SETTING_SIMILARITY,
TEXT_SIMILARITY, 1, 1000, 1);
obs_properties_add_int_slider(props, SETTING_SMOOTHNESS,
TEXT_SMOOTHNESS, 1, 1000, 1);
obs_properties_add_int_slider(props, SETTING_SPILL,
TEXT_SPILL, 1, 1000, 1);
obs_properties_add_int(props, SETTING_OPACITY, TEXT_OPACITY, 0, 100, 1);
obs_properties_add_float_slider(props, SETTING_CONTRAST,
TEXT_CONTRAST, -1.0, 1.0, 0.01);
obs_properties_add_float_slider(props, SETTING_BRIGHTNESS,
TEXT_BRIGHTNESS, -1.0, 1.0, 0.01);
obs_properties_add_float_slider(props, SETTING_GAMMA,
TEXT_GAMMA, -1.0, 1.0, 0.01);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t *rtmp_stream_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
struct netif_saddr_data addrs = {0};
obs_property_t *p;
obs_properties_add_int(props, OPT_DROP_THRESHOLD,
obs_module_text("RTMPStream.DropThreshold"),
200, 10000, 100);
p = obs_properties_add_list(props, OPT_BIND_IP,
obs_module_text("RTMPStream.BindIP"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(p, obs_module_text("Default"), "default");
netif_get_addrs(&addrs);
for (size_t i = 0; i < addrs.addrs.num; i++) {
struct netif_saddr_item item = addrs.addrs.array[i];
obs_property_list_add_string(p, item.name, item.addr);
}
netif_saddr_data_free(&addrs);
return props;
}
static obs_properties_t *image_source_properties(void *data)
{
struct image_source *s = data;
struct dstr path = {0};
obs_properties_t *props = obs_properties_create();
if (s && s->file && *s->file) {
const char *slash;
dstr_copy(&path, s->file);
dstr_replace(&path, "\\", "/");
slash = strrchr(path.array, '/');
if (slash)
dstr_resize(&path, slash - path.array + 1);
}
obs_properties_add_path(props,
"file", obs_module_text("File"),
OBS_PATH_FILE, image_filter, path.array);
obs_properties_add_bool(props,
"unload", obs_module_text("UnloadWhenNotShowing"));
dstr_free(&path);
return props;
}
/**
* Get the properties for the capture
*/
static obs_properties_t *xshm_properties(void *vptr)
{
XSHM_DATA(vptr);
obs_properties_t *props = obs_properties_create();
obs_properties_add_list(props, "screen", obs_module_text("Screen"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_properties_add_bool(props, "show_cursor",
obs_module_text("CaptureCursor"));
obs_property_t *advanced = obs_properties_add_bool(props, "advanced",
obs_module_text("AdvancedSettings"));
obs_property_t *server = obs_properties_add_text(props, "server",
obs_module_text("XServer"), OBS_TEXT_DEFAULT);
obs_property_set_modified_callback(advanced, xshm_toggle_advanced);
obs_property_set_modified_callback(server, xshm_server_changed);
/* trigger server callback to get screen count ... */
obs_data_t *settings = obs_source_get_settings(data->source);
obs_property_modified(server, settings);
obs_data_release(settings);
return props;
}
static obs_properties_t libfdk_properties(void)
{
obs_properties_t props = obs_properties_create();
obs_properties_add_int(props, "bitrate",
obs_module_text("Bitrate"), 32, 256, 32);
obs_properties_add_bool(props, "afterburner",
obs_module_text("Afterburner"));
return props;
}
obs_properties_t *obstudio_infowriter_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_properties_add_path(props, setting_file, obs_module_text("Logfile"), OBS_PATH_FILE_SAVE, logfile_filter, NULL);
obs_properties_add_text(props, setting_format, obs_module_text("Format"), OBS_TEXT_DEFAULT);
return props;
}
static bool transition_point_type_modified(obs_properties_t *ppts,
obs_property_t *p, obs_data_t *s)
{
int64_t type = obs_data_get_int(s, "tp_type");
p = obs_properties_get(ppts, "transition_point");
if (type == TIMING_TIME)
obs_property_set_description(p,
obs_module_text("TransitionPoint"));
else
obs_property_set_description(p,
obs_module_text("TransitionPointFrame"));
return true;
}
/*
* List dv timings for the device
*/
static void v4l2_dv_timing_list(int dev, obs_property_t *prop)
{
struct v4l2_dv_timings dvt;
struct dstr buf;
int index = 0;
dstr_init(&buf);
obs_property_list_clear(prop);
obs_property_list_add_int(prop, obs_module_text("LeaveUnchanged"), -1);
while (v4l2_enum_dv_timing(dev, &dvt, index) == 0) {
/* i do not pretend to understand, this is from qv4l2 ... */
double h = (double) dvt.bt.height + dvt.bt.vfrontporch +
dvt.bt.vsync + dvt.bt.vbackporch +
dvt.bt.il_vfrontporch + dvt.bt.il_vsync +
dvt.bt.il_vbackporch;
double w = (double) dvt.bt.width + dvt.bt.hfrontporch +
dvt.bt.hsync + dvt.bt.hbackporch;
double i = (dvt.bt.interlaced) ? 2.0f : 1.0f;
double rate = (double) dvt.bt.pixelclock / (w * (h / i));
dstr_printf(&buf, "%ux%u%c %.2f",
dvt.bt.width, dvt.bt.height,
(dvt.bt.interlaced) ? 'i' : 'p', rate);
obs_property_list_add_int(prop, buf.array, index);
index++;
}
dstr_free(&buf);
}
obs_properties_t XCompcapMain::properties()
{
obs_properties_t props = obs_properties_create();
obs_property_t wins = obs_properties_add_list(props, "capture_window",
obs_module_text("Window"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
for (Window win: XCompcap::getTopLevelWindows()) {
std::string wname = XCompcap::getWindowName(win);
std::string progpath = XCompcap::getWindowCommand(win);
std::string winid = std::to_string((long long)win);
std::string desc =
(winid + WIN_STRING_DIV + wname +
WIN_STRING_DIV + progpath);
obs_property_list_add_string(wins, wname.c_str(),
desc.c_str());
}
obs_properties_add_int(props, "cut_top", obs_module_text("CropTop"),
0, 4096, 1);
obs_properties_add_int(props, "cut_left", obs_module_text("CropLeft"),
0, 4096, 1);
obs_properties_add_int(props, "cut_right", obs_module_text("CropRight"),
0, 4096, 1);
obs_properties_add_int(props, "cut_bot", obs_module_text("CropBottom"),
0, 4096, 1);
obs_properties_add_bool(props, "swap_redblue",
obs_module_text("SwapRedBlue"));
obs_properties_add_bool(props, "lock_x", obs_module_text("LockX"));
return props;
}
static obs_properties_t *crop_filter_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *p = obs_properties_add_bool(props, "relative",
obs_module_text("Crop.Relative"));
obs_property_set_modified_callback(p, relative_clicked);
obs_properties_add_int(props, "left", obs_module_text("Crop.Left"),
0, 8192, 1);
obs_properties_add_int(props, "top", obs_module_text("Crop.Top"),
0, 8192, 1);
obs_properties_add_int(props, "right", obs_module_text("Crop.Right"),
0, 8192, 1);
obs_properties_add_int(props, "bottom", obs_module_text("Crop.Bottom"),
0, 8192, 1);
obs_properties_add_int(props, "cx", obs_module_text("Crop.Width"),
0, 8192, 1);
obs_properties_add_int(props, "cy", obs_module_text("Crop.Height"),
0, 8192, 1);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t* python_source_properties(void* data)
{
UNUSED_PARAMETER(data);
obs_properties_t* props = obs_properties_create();
obs_properties_add_text(props, "text",obs_module_text("Text"), OBS_TEXT_MULTILINE);
return props;
}
static bool relative_clicked(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings)
{
bool relative = obs_data_get_bool(settings, "relative");
obs_property_set_description(obs_properties_get(props, "left"),
relative ? obs_module_text("Crop.Left") : "X");
obs_property_set_description(obs_properties_get(props, "top"),
relative ? obs_module_text("Crop.Top") : "Y");
obs_property_set_visible(obs_properties_get(props, "right"), relative);
obs_property_set_visible(obs_properties_get(props, "bottom"), relative);
obs_property_set_visible(obs_properties_get(props, "cx"), !relative);
obs_property_set_visible(obs_properties_get(props, "cy"), !relative);
UNUSED_PARAMETER(p);
return true;
}
static void *qtwebkit_create(obs_data_t *settings, obs_source_t *source)
{
UNUSED_PARAMETER(settings);
QtWebkitSource *ws = new QtWebkitSource(source);
ws->UpdateSettings(settings);
ws->reload_key = obs_hotkey_register_source(source, "qtwebkit.reload", obs_module_text("Reload"),
reload_hotkey_pressed, ws);
return ws;
}
obs_properties_t *XCompcapMain::properties()
{
obs_properties_t *props = obs_properties_create();
obs_property_t *wins = obs_properties_add_list(props, "capture_window",
obs_module_text("Window"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
for (Window win: XCompcap::getTopLevelWindows()) {
std::string wname = XCompcap::getWindowName(win);
std::string cls = XCompcap::getWindowClass(win);
std::string winid = std::to_string((long long)win);
std::string desc =
(winid + WIN_STRING_DIV + wname +
WIN_STRING_DIV + cls);
obs_property_list_add_string(wins, wname.c_str(),
desc.c_str());
}
obs_properties_add_int(props, "cut_top", obs_module_text("CropTop"),
0, 4096, 1);
obs_properties_add_int(props, "cut_left", obs_module_text("CropLeft"),
0, 4096, 1);
obs_properties_add_int(props, "cut_right", obs_module_text("CropRight"),
0, 4096, 1);
obs_properties_add_int(props, "cut_bot", obs_module_text("CropBottom"),
0, 4096, 1);
obs_properties_add_bool(props, "swap_redblue",
obs_module_text("SwapRedBlue"));
obs_properties_add_bool(props, "lock_x", obs_module_text("LockX"));
obs_properties_add_bool(props, "show_cursor",
obs_module_text("CaptureCursor"));
obs_properties_add_bool(props, "include_border",
obs_module_text("IncludeXBorder"));
obs_properties_add_bool(props, "exclude_alpha",
obs_module_text("ExcludeAlpha"));
return props;
}
static obs_properties_t *vaapi_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_property_t * list;
list = obs_properties_add_list(props, "vaapi_device", "VAAPI Device",
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
char path[128] = "/dev/dri/renderD1";
for (int i = 28;; i++) {
sprintf(path, "/dev/dri/renderD1%d", i);
if (access(path, F_OK) == 0) {
char card[128] = "Card: ";
sprintf(card, "Card%d: %s", i - 28, path);
obs_property_list_add_string(list, card, path);
} else {
break;
}
}
list = obs_properties_add_list(props, "vaapi_codec", "VAAPI Codec",
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(list, "H.264 (default)", AV_CODEC_ID_H264);
list = obs_properties_add_list(props, "level", "Level",
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(list, "480p30 (3.0)", 30);
obs_property_list_add_int(list, "720p30/480p60 (3.1)", 31);
obs_property_list_add_int(
list, "Compatibility mode (4.0 default)", 40);
obs_property_list_add_int(list, "720p60/1080p30 (4.1)", 41);
obs_property_list_add_int(list, "1080p60 (4.2)", 42);
obs_properties_add_int(props, "bitrate", obs_module_text("Bitrate"), 0,
300000, 50);
obs_properties_add_int(props, "keyint_sec",
obs_module_text("Keyframe Interval (seconds)"), 0, 20,
1);
return props;
}
static obs_properties_t image_source_properties(void)
{
obs_properties_t props = obs_properties_create();
obs_properties_add_path(props,
"file", obs_module_text("File"),
OBS_PATH_FILE, image_filter, NULL);
return props;
}
/**
* Get the properties for the capture
*/
static obs_properties_t xshm_properties(void)
{
obs_properties_t props = obs_properties_create();
int_fast32_t screen_max;
Display *dpy = XOpenDisplay(NULL);
screen_max = xinerama_is_active(dpy)
? xinerama_screen_count(dpy)
: XScreenCount(dpy);
screen_max = (screen_max) ? screen_max - 1 : 0;
XCloseDisplay(dpy);
obs_properties_add_int(props, "screen",
obs_module_text("Screen"), 0, screen_max, 1);
obs_properties_add_bool(props, "show_cursor",
obs_module_text("CaptureCursor"));
return props;
}
static obs_properties_t *aac_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_properties_add_int(props, "bitrate",
obs_module_text("Bitrate"), 32, 320, 32);
return props;
}
static obs_properties_t *flv_output_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_properties_add_text(props, "path",
obs_module_text("FLVOutput.FilePath"),
OBS_TEXT_DEFAULT);
return props;
}
static obs_properties_t *rtmp_stream_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_properties_add_int(props, OPT_DROP_THRESHOLD,
obs_module_text("RTMPStream.DropThreshold"),
200, 10000, 100);
return props;
}
static obs_properties_t *rtmp_custom_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *ppts = obs_properties_create();
obs_property_t *p;
obs_properties_add_text(ppts, "server", "URL", OBS_TEXT_DEFAULT);
obs_properties_add_text(ppts, "key", obs_module_text("StreamKey"),
OBS_TEXT_PASSWORD);
p = obs_properties_add_bool(ppts, "use_auth", obs_module_text("UseAuth"));
obs_properties_add_text(ppts, "username", obs_module_text("Username"),
OBS_TEXT_DEFAULT);
obs_properties_add_text(ppts, "password", obs_module_text("Password"),
OBS_TEXT_PASSWORD);
obs_property_set_modified_callback(p, use_auth_modified);
return ppts;
}
static obs_properties_t *v4l2_properties(void *vptr)
{
V4L2_DATA(vptr);
obs_properties_t *props = obs_properties_create();
obs_property_t *device_list = obs_properties_add_list(props,
"device_id", obs_module_text("Device"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_t *input_list = obs_properties_add_list(props,
"input", obs_module_text("Input"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_t *format_list = obs_properties_add_list(props,
"pixelformat", obs_module_text("VideoFormat"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_t *standard_list = obs_properties_add_list(props,
"standard", obs_module_text("VideoStandard"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_visible(standard_list, false);
obs_property_t *dv_timing_list = obs_properties_add_list(props,
"dv_timing", obs_module_text("DVTiming"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_visible(dv_timing_list, false);
obs_property_t *resolution_list = obs_properties_add_list(props,
"resolution", obs_module_text("Resolution"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_properties_add_list(props,
"framerate", obs_module_text("FrameRate"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_properties_add_bool(props,
"buffering", obs_module_text("UseBuffering"));
obs_data_t *settings = obs_source_get_settings(data->source);
v4l2_device_list(device_list, settings);
obs_data_release(settings);
obs_property_set_modified_callback(device_list, device_selected);
obs_property_set_modified_callback(input_list, input_selected);
obs_property_set_modified_callback(format_list, format_selected);
obs_property_set_modified_callback(resolution_list,
resolution_selected);
return props;
}
/**
* Get plugin properties
*/
static obs_properties_t *pulse_properties(bool input)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *devices = obs_properties_add_list(props, "device_id",
obs_module_text("Device"), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
pulse_init();
if (input)
pulse_get_source_info_list(pulse_input_info, (void *) devices);
else
pulse_get_sink_info_list(pulse_output_info, (void *) devices);
pulse_unref();
size_t count = obs_property_list_item_count(devices);
if (count > 0)
obs_property_list_insert_string(devices, 0,
obs_module_text("Default"), "default");
return props;
}
/*
* List video standards for the device
*/
static void v4l2_standard_list(int dev, obs_property_t *prop)
{
struct v4l2_standard std;
std.index = 0;
obs_property_list_clear(prop);
obs_property_list_add_int(prop, obs_module_text("LeaveUnchanged"), -1);
while (v4l2_ioctl(dev, VIDIOC_ENUMSTD, &std) == 0) {
obs_property_list_add_int(prop, (char *) std.name, std.id);
std.index++;
}
}
/**
* Get plugin properties
*/
static obs_properties_t *pulse_properties(bool input)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *devices = obs_properties_add_list(props, "device_id",
obs_module_text("Device"), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
pulse_init();
pa_source_info_cb_t cb = (input) ? pulse_input_info : pulse_output_info;
pulse_get_source_info_list(cb, (void *) devices);
pulse_unref();
return props;
}
/*
* List framerates for device and resolution
*/
static void v4l2_framerate_list(int dev, uint_fast32_t pixelformat,
uint_fast32_t width, uint_fast32_t height, obs_property_t *prop)
{
struct v4l2_frmivalenum frmival;
frmival.pixel_format = pixelformat;
frmival.width = width;
frmival.height = height;
frmival.index = 0;
struct dstr buffer;
dstr_init(&buffer);
obs_property_list_clear(prop);
obs_property_list_add_int(prop, obs_module_text("LeaveUnchanged"), -1);
v4l2_ioctl(dev, VIDIOC_ENUM_FRAMEINTERVALS, &frmival);
switch(frmival.type) {
case V4L2_FRMIVAL_TYPE_DISCRETE:
while (v4l2_ioctl(dev, VIDIOC_ENUM_FRAMEINTERVALS,
&frmival) == 0) {
float fps = (float) frmival.discrete.denominator /
frmival.discrete.numerator;
int pack = v4l2_pack_tuple(frmival.discrete.numerator,
frmival.discrete.denominator);
dstr_printf(&buffer, "%.2f", fps);
obs_property_list_add_int(prop, buffer.array, pack);
frmival.index++;
}
break;
default:
blog(LOG_INFO, "Stepwise and Continuous framerates "
"are currently hardcoded");
for (const int *packed = v4l2_framerates; *packed; ++packed) {
int num;
int denom;
v4l2_unpack_tuple(&num, &denom, *packed);
float fps = (float) denom / num;
dstr_printf(&buffer, "%.2f", fps);
obs_property_list_add_int(prop, buffer.array, *packed);
}
break;
}
dstr_free(&buffer);
}
ScriptLogWindow::ScriptLogWindow() : QWidget(nullptr)
{
const QFont fixedFont =
QFontDatabase::systemFont(QFontDatabase::FixedFont);
QPlainTextEdit *edit = new QPlainTextEdit();
edit->setReadOnly(true);
edit->setFont(fixedFont);
edit->setWordWrapMode(QTextOption::NoWrap);
QHBoxLayout *buttonLayout = new QHBoxLayout();
QPushButton *clearButton = new QPushButton(tr("Clear"));
connect(clearButton, &QPushButton::clicked,
this, &ScriptLogWindow::ClearWindow);
QPushButton *closeButton = new QPushButton(tr("Close"));
connect(closeButton, &QPushButton::clicked,
this, &QDialog::hide);
buttonLayout->addStretch();
buttonLayout->addWidget(clearButton);
buttonLayout->addWidget(closeButton);
QVBoxLayout *layout = new QVBoxLayout();
layout->addWidget(edit);
layout->addLayout(buttonLayout);
setLayout(layout);
scriptLogWidget = edit;
resize(600, 400);
config_t *global_config = obs_frontend_get_global_config();
const char *geom = config_get_string(global_config,
"ScriptLogWindow", "geometry");
if (geom != nullptr) {
QByteArray ba = QByteArray::fromBase64(QByteArray(geom));
restoreGeometry(ba);
}
setWindowTitle(obs_module_text("ScriptLogWindow"));
connect(edit->verticalScrollBar(), &QAbstractSlider::sliderMoved,
this, &ScriptLogWindow::ScrollChanged);
}
extern "C" void InitScripts()
{
scriptLogWindow = new ScriptLogWindow();
obs_scripting_load();
obs_scripting_set_log_callback(script_log, nullptr);
QAction *action = (QAction*)obs_frontend_add_tools_menu_qaction(
obs_module_text("Scripts"));
#if PYTHON_UI
config_t *config = obs_frontend_get_global_config();
const char *python_path = config_get_string(config, "Python",
"Path" ARCH_NAME);
if (!obs_scripting_python_loaded() && python_path && *python_path)
obs_scripting_load_python(python_path);
#endif
scriptData = new ScriptData;
auto cb = [] ()
{
obs_frontend_push_ui_translation(obs_module_get_string);
if (!scriptsWindow) {
scriptsWindow = new ScriptsTool();
scriptsWindow->show();
} else {
scriptsWindow->show();
scriptsWindow->raise();
}
obs_frontend_pop_ui_translation();
};
obs_frontend_add_save_callback(save_script_data, nullptr);
obs_frontend_add_preload_callback(load_script_data, nullptr);
obs_frontend_add_event_callback(obs_event, nullptr);
action->connect(action, &QAction::triggered, cb);
}
/*
* List resolutions for device and format
*/
static void v4l2_resolution_list(int dev, uint_fast32_t pixelformat,
obs_property_t *prop)
{
struct v4l2_frmsizeenum frmsize;
frmsize.pixel_format = pixelformat;
frmsize.index = 0;
struct dstr buffer;
dstr_init(&buffer);
obs_property_list_clear(prop);
obs_property_list_add_int(prop, obs_module_text("LeaveUnchanged"), -1);
v4l2_ioctl(dev, VIDIOC_ENUM_FRAMESIZES, &frmsize);
switch(frmsize.type) {
case V4L2_FRMSIZE_TYPE_DISCRETE:
while (v4l2_ioctl(dev, VIDIOC_ENUM_FRAMESIZES, &frmsize) == 0) {
dstr_printf(&buffer, "%dx%d", frmsize.discrete.width,
frmsize.discrete.height);
obs_property_list_add_int(prop, buffer.array,
v4l2_pack_tuple(frmsize.discrete.width,
frmsize.discrete.height));
frmsize.index++;
}
break;
default:
blog(LOG_INFO, "Stepwise and Continuous framesizes "
"are currently hardcoded");
for (const int *packed = v4l2_framesizes; *packed; ++packed) {
int width;
int height;
v4l2_unpack_tuple(&width, &height, *packed);
dstr_printf(&buffer, "%dx%d", width, height);
obs_property_list_add_int(prop, buffer.array, *packed);
}
break;
}
dstr_free(&buffer);
}
static obs_properties_t *qtwebkit_get_properties(void *)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *prop = obs_properties_add_bool(props, "is_local_file",
obs_module_text("LocalFile"));
obs_property_set_modified_callback(prop, is_local_file_modified);
obs_properties_add_path(props, "local_file", obs_module_text("LocalFile"),
OBS_PATH_FILE, "*.*", nullptr);
obs_properties_add_text(props, "url", obs_module_text("URL"), OBS_TEXT_DEFAULT);
obs_properties_add_int(props, "width", obs_module_text("Width"), 1, 4096, 1);
obs_properties_add_int(props, "height", obs_module_text("Height"), 1, 4096, 1);
obs_properties_add_int(props, "fps", obs_module_text("FPS"), 1, 60, 1);
obs_properties_add_path(props, "css_file", obs_module_text("CustomCSS"),
OBS_PATH_FILE, "*.css", nullptr);
obs_properties_add_button(props, "reload", obs_module_text("Reload"), reload_button_clicked);
return props;
}