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 *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;
}
obs_properties_t XCompcapMain::properties()
{
obs_properties_t props = obs_properties_create();
obs_property_t wins = obs_properties_add_list(props, "capture_window",
"Captured 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", "Cut top pixels",
0, 4096, 1);
obs_properties_add_int(props, "cut_left", "Cut left pixels",
0, 4096, 1);
obs_properties_add_int(props, "cut_right", "Cut right pixels",
0, 4096, 1);
obs_properties_add_int(props, "cut_bot", "Cut bottom pixels",
0, 4096, 1);
obs_properties_add_bool(props, "swap_redblue", "Swap red and blue");
obs_properties_add_bool(props, "lock_x", "Lock X server when "
"capturing");
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 *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 *decklink_get_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *list = obs_properties_add_list(props, DEVICE_HASH,
TEXT_DEVICE, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback(list, decklink_device_changed);
fill_out_devices(list);
list = obs_properties_add_list(props, MODE_ID, TEXT_MODE,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
list = obs_properties_add_list(props, PIXEL_FORMAT,
TEXT_PIXEL_FORMAT, OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(list, "8-bit YUV", bmdFormat8BitYUV);
obs_property_list_add_int(list, "8-bit BGRA", bmdFormat8BitBGRA);
list = obs_properties_add_list(props, CHANNEL_FORMAT,
TEXT_CHANNEL_FORMAT, OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(list, TEXT_CHANNEL_FORMAT_NONE,
SPEAKERS_UNKNOWN);
obs_property_list_add_int(list, TEXT_CHANNEL_FORMAT_2_0CH,
SPEAKERS_STEREO);
obs_properties_add_bool(props, BUFFERING, TEXT_BUFFERING);
UNUSED_PARAMETER(data);
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;
}
static obs_properties_t *color_grade_filter_properties(void *data)
{
struct lut_filter_data *s = data;
struct dstr path = {0};
const char *slash;
obs_properties_t *props = obs_properties_create();
struct dstr filter_str = {0};
dstr_cat(&filter_str, "(*.png)");
if (s && s->file && *s->file) {
dstr_copy(&path, s->file);
} else {
dstr_copy(&path, obs_module_file("LUTs"));
dstr_cat_ch(&path, '/');
}
dstr_replace(&path, "\\", "/");
slash = strrchr(path.array, '/');
if (slash)
dstr_resize(&path, slash - path.array + 1);
obs_properties_add_path(props, SETTING_IMAGE_PATH, TEXT_IMAGE_PATH,
OBS_PATH_FILE, filter_str.array, path.array);
obs_properties_add_float_slider(props, SETTING_CLUT_AMOUNT,
TEXT_AMOUNT, 0, 1, 0.01);
dstr_free(&filter_str);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t aac_properties(const char *locale)
{
obs_properties_t props = obs_properties_create(locale);
/* TODO: locale */
obs_properties_add_int(props, "bitrate", "Bitrate", 32, 320, 32);
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 obs_properties_t *scale_filter_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
struct obs_video_info ovi;
obs_property_t *p;
uint32_t cx;
uint32_t cy;
struct {
int cx;
int cy;
} downscales[NUM_DOWNSCALES];
/* ----------------- */
obs_get_video_info(&ovi);
cx = ovi.base_width;
cy = ovi.base_height;
for (size_t i = 0; i < NUM_DOWNSCALES; i++) {
downscales[i].cx = (int)((double)cx / downscale_vals[i]);
downscales[i].cy = (int)((double)cy / downscale_vals[i]);
}
p = obs_properties_add_list(props, S_SAMPLING, T_SAMPLING,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback(p, sampling_modified);
obs_property_list_add_string(p, T_SAMPLING_POINT, S_SAMPLING_POINT);
obs_property_list_add_string(p, T_SAMPLING_BILINEAR, S_SAMPLING_BILINEAR);
obs_property_list_add_string(p, T_SAMPLING_BICUBIC, S_SAMPLING_BICUBIC);
obs_property_list_add_string(p, T_SAMPLING_LANCZOS, S_SAMPLING_LANCZOS);
/* ----------------- */
p = obs_properties_add_list(props, S_RESOLUTION, T_RESOLUTION,
OBS_COMBO_TYPE_EDITABLE, OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(p, T_NONE, T_NONE);
obs_property_list_add_string(p, T_BASE, T_BASE);
for (size_t i = 0; i < NUM_ASPECTS; i++)
obs_property_list_add_string(p, aspects[i], aspects[i]);
for (size_t i = 0; i < NUM_DOWNSCALES; i++) {
char str[32];
snprintf(str, 32, "%dx%d", downscales[i].cx, downscales[i].cy);
obs_property_list_add_string(p, str, str);
}
obs_properties_add_bool(props, S_UNDISTORT, T_UNDISTORT);
/* ----------------- */
UNUSED_PARAMETER(data);
return props;
}
/*
* get plugin properties
*/
static obs_properties_t pulse_properties(const char *locale, bool input)
{
blog(LOG_DEBUG, "pulse-input: properties requested !");
obs_properties_t props = obs_properties_create(locale);
pulse_enumerate_devices(props, input);
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 *gain_properties(void *data)
{
obs_properties_t *ppts = obs_properties_create();
obs_properties_add_float_slider(ppts, S_GAIN_DB, TEXT_GAIN_DB,
-30.0, 30.0, 0.1);
UNUSED_PARAMETER(data);
return ppts;
}
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;
}
static obs_properties_t *sharpness_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_properties_add_float_slider(props, "sharpness",
"Sharpness", 0.0f, 1.0f, 0.01f);
UNUSED_PARAMETER(data);
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 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;
}
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 *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 *stinger_properties(void *data)
{
obs_properties_t *ppts = obs_properties_create();
obs_properties_set_flags(ppts, OBS_PROPERTIES_DEFER_UPDATE);
obs_properties_add_path(ppts, "path",
obs_module_text("VideoFile"),
OBS_PATH_FILE,
FILE_FILTER, NULL);
obs_property_t *list = obs_properties_add_list(ppts, "tp_type",
obs_module_text("TransitionPointType"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(list,
obs_module_text("TransitionPointTypeTime"),
TIMING_TIME);
obs_property_list_add_int(list,
obs_module_text("TransitionPointTypeFrame"),
TIMING_FRAME);
obs_property_set_modified_callback(list, transition_point_type_modified);
obs_properties_add_int(ppts, "transition_point",
obs_module_text("TransitionPoint"),
0, 120000, 1);
obs_property_t *monitor_list = obs_properties_add_list(ppts,
"audio_monitoring", obs_module_text("AudioMonitoring"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(monitor_list,
obs_module_text("AudioMonitoring.None"),
OBS_MONITORING_TYPE_NONE);
obs_property_list_add_int(monitor_list,
obs_module_text("AudioMonitoring.MonitorOnly"),
OBS_MONITORING_TYPE_MONITOR_ONLY);
obs_property_list_add_int(monitor_list,
obs_module_text("AudioMonitoring.Both"),
OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT);
obs_property_t *audio_fade_style = obs_properties_add_list(ppts,
"audio_fade_style", obs_module_text("AudioFadeStyle"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(audio_fade_style,
obs_module_text("AudioFadeStyle.FadeOutFadeIn"),
FADE_STYLE_FADE_OUT_FADE_IN);
obs_property_list_add_int(audio_fade_style,
obs_module_text("AudioFadeStyle.CrossFade"),
FADE_STYLE_CROSS_FADE);
UNUSED_PARAMETER(data);
return ppts;
}
static obs_properties_t rtmp_stream_properties(const char *locale)
{
obs_properties_t props = obs_properties_create(locale);
/* TODO: locale */
obs_properties_add_text(props, "path", "Stream URL", OBS_TEXT_DEFAULT);
obs_properties_add_text(props, "key", "Stream Key", OBS_TEXT_PASSWORD);
obs_properties_add_text(props, "username", "User Name",
OBS_TEXT_DEFAULT);
obs_properties_add_text(props, "password", "Password",
OBS_TEXT_PASSWORD);
return props;
}
/**
* Get plugin properties
*/
static obs_properties_t pulse_properties(const char *locale, bool input)
{
obs_properties_t props = obs_properties_create(locale);
obs_property_t devices = obs_properties_add_list(props, "device_id",
"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;
}
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();
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;
}
static obs_properties_t *ft2_source_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
//obs_property_t *prop;
// TODO:
// Scrolling. Can't think of a way to do it with the render
// targets currently being broken. (0.4.2)
// Better/pixel shader outline/drop shadow
// Some way to pull text files from network, I dunno
obs_properties_add_font(props, "font",
obs_module_text("Font"));
obs_properties_add_text(props, "text",
obs_module_text("Text"), OBS_TEXT_MULTILINE);
obs_properties_add_bool(props, "from_file",
obs_module_text("ReadFromFile"));
obs_properties_add_bool(props, "log_mode",
obs_module_text("ChatLogMode"));
obs_properties_add_path(props,
"text_file", obs_module_text("TextFile"),
OBS_PATH_FILE, obs_module_text("TextFileFilter"), NULL);
obs_properties_add_color(props, "color1",
obs_module_text("Color1"));
obs_properties_add_color(props, "color2",
obs_module_text("Color2"));
obs_properties_add_bool(props, "outline",
obs_module_text("Outline"));
obs_properties_add_bool(props, "drop_shadow",
obs_module_text("DropShadow"));
obs_properties_add_int(props, "custom_width",
obs_module_text("CustomWidth"), 0, 4096, 1);
obs_properties_add_bool(props, "word_wrap",
obs_module_text("WordWrap"));
return props;
}
// Creates all of the properties or "settings" for our source
static obs_properties_t *destiny_detail_properties(void *data)
{
UNUSED_PARAMETER(data);
obs_properties_t *props = obs_properties_create();
obs_properties_add_int(
props,
"account_id",
"AccountID",
0,
INT_MAX,
1);
return props;
}
static obs_properties_t *monitor_capture_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_property_t *monitors = obs_properties_add_list(props,
"monitor", TEXT_MONITOR,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_properties_add_bool(props, "compatibility", TEXT_COMPATIBILITY);
obs_properties_add_bool(props, "capture_cursor", TEXT_CAPTURE_CURSOR);
EnumDisplayMonitors(NULL, NULL, enum_monitor_props, (LPARAM)monitors);
return props;
}
static obs_properties_t *color_filter_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_properties_add_color(props, SETTING_COLOR, TEXT_COLOR);
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;
}
