static inline void chroma_settings_update(
struct chroma_key_filter_data *filter, obs_data_t *settings)
{
int64_t similarity = obs_data_get_int(settings, SETTING_SIMILARITY);
int64_t smoothness = obs_data_get_int(settings, SETTING_SMOOTHNESS);
int64_t spill = obs_data_get_int(settings, SETTING_SPILL);
uint32_t key_color = (uint32_t)obs_data_get_int(settings,
SETTING_KEY_COLOR);
const char *key_type = obs_data_get_string(settings,
SETTING_COLOR_TYPE);
struct vec4 key_color_v4;
struct matrix4 yuv_mat_m4;
if (strcmp(key_type, "green") == 0)
key_color = 0x00FF00;
else if (strcmp(key_type, "blue") == 0)
key_color = 0xFF9900;
else if (strcmp(key_type, "magenta") == 0)
key_color = 0xFF00FF;
vec4_from_rgba(&filter->key_rgb, key_color | 0xFF000000);
memcpy(&yuv_mat_m4, yuv_mat, sizeof(yuv_mat));
vec4_transform(&key_color_v4, &filter->key_rgb, &yuv_mat_m4);
vec2_set(&filter->chroma, key_color_v4.y, key_color_v4.z);
filter->similarity = (float)similarity / 1000.0f;
filter->smoothness = (float)smoothness / 1000.0f;
filter->spill = (float)spill / 1000.0f;
}
static void noise_gate_update(void *data, obs_data_t *s)
{
struct noise_gate_data *ng = data;
float open_threshold_db;
float close_threshold_db;
float sample_rate;
int attack_time_ms;
int hold_time_ms;
int release_time_ms;
open_threshold_db = (float)obs_data_get_double(s, S_OPEN_THRESHOLD);
close_threshold_db = (float)obs_data_get_double(s, S_CLOSE_THRESHOLD);
attack_time_ms = (int)obs_data_get_int(s, S_ATTACK_TIME);
hold_time_ms = (int)obs_data_get_int(s, S_HOLD_TIME);
release_time_ms = (int)obs_data_get_int(s, S_RELEASE_TIME);
sample_rate = (float)audio_output_get_sample_rate(obs_get_audio());
ng->sample_rate_i = 1.0f / sample_rate;
ng->channels = audio_output_get_channels(obs_get_audio());
ng->open_threshold = db_to_mul(open_threshold_db);
ng->close_threshold = db_to_mul(close_threshold_db);
ng->attack_rate = 1.0f / (ms_to_secf(attack_time_ms) * sample_rate);
ng->release_rate = 1.0f / (ms_to_secf(release_time_ms) * sample_rate);
const float threshold_diff = ng->open_threshold - ng->close_threshold;
const float min_decay_period = (1.0f / 75.0f) * sample_rate;
ng->decay_rate = threshold_diff / min_decay_period;
ng->hold_time = ms_to_secf(hold_time_ms);
ng->is_open = false;
ng->attenuation = 0.0f;
ng->level = 0.0f;
ng->held_time = 0.0f;
}
static void color_filter_update(void *data, obs_data_t *settings)
{
struct color_filter_data *filter = data;
uint32_t color = (uint32_t)obs_data_get_int(settings, SETTING_COLOR);
uint32_t opacity = (uint32_t)obs_data_get_int(settings,
SETTING_OPACITY);
double contrast = obs_data_get_double(settings, SETTING_CONTRAST);
double brightness = obs_data_get_double(settings, SETTING_BRIGHTNESS);
double gamma = obs_data_get_double(settings, SETTING_GAMMA);
color &= 0xFFFFFF;
color |= ((opacity * 255) / 100) << 24;
vec4_from_rgba(&filter->color, color);
contrast = (contrast < 0.0) ?
(1.0 / (-contrast + 1.0)) : (contrast + 1.0);
brightness *= 0.5;
gamma = (gamma < 0.0) ? (-gamma + 1.0) : (1.0 / (gamma + 1.0));
filter->contrast = (float)contrast;
filter->brightness = (float)brightness;
filter->gamma = (float)gamma;
}
static bool init_connect(struct rtmp_stream *stream)
{
obs_service_t *service;
obs_data_t *settings;
if (stopping(stream))
pthread_join(stream->send_thread, NULL);
free_packets(stream);
service = obs_output_get_service(stream->output);
if (!service)
return false;
os_atomic_set_bool(&stream->disconnected, false);
stream->total_bytes_sent = 0;
stream->dropped_frames = 0;
stream->min_drop_dts_usec= 0;
stream->min_priority = 0;
settings = obs_output_get_settings(stream->output);
dstr_copy(&stream->path, obs_service_get_url(service));
dstr_copy(&stream->key, obs_service_get_key(service));
dstr_copy(&stream->username, obs_service_get_username(service));
dstr_copy(&stream->password, obs_service_get_password(service));
stream->drop_threshold_usec =
(int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD) * 1000;
stream->max_shutdown_time_sec =
(int)obs_data_get_int(settings, OPT_MAX_SHUTDOWN_TIME_SEC);
obs_data_release(settings);
return true;
}
//对字体的支持
QFont obs_data_get_qfont(obs_data_t *data, const char *name){
obs_data_t *font_obj = obs_data_get_obj(data, name);
const char *face = obs_data_get_string(font_obj, "face");
const char *style = obs_data_get_string(font_obj, "style");
int size = (int)obs_data_get_int(font_obj, "size");
uint32_t flags = (uint32_t)obs_data_get_int(font_obj, "flags");
QFont font;
if (face) {
font.setFamily(face);
font.setStyleName(style);
}
if (size)
font.setPointSize(size);
if (flags & OBS_FONT_BOLD) font.setBold(true);
if (flags & OBS_FONT_ITALIC) font.setItalic(true);
if (flags & OBS_FONT_UNDERLINE) font.setUnderline(true);
if (flags & OBS_FONT_STRIKEOUT) font.setStrikeOut(true);
return font;
}
static void expander_update(void *data, obs_data_t *s)
{
struct expander_data *cd = data;
const char *presets = obs_data_get_string(s, S_PRESETS);
if (strcmp(presets, "expander") == 0 && cd->is_gate) {
obs_data_clear(s);
obs_data_set_string(s, S_PRESETS, "expander");
expander_defaults(s);
cd->is_gate = false;
}
if (strcmp(presets, "gate") == 0 && !cd->is_gate) {
obs_data_clear(s);
obs_data_set_string(s, S_PRESETS, "gate");
expander_defaults(s);
cd->is_gate = true;
}
const uint32_t sample_rate =
audio_output_get_sample_rate(obs_get_audio());
const size_t num_channels =
audio_output_get_channels(obs_get_audio());
const float attack_time_ms =
(float)obs_data_get_int(s, S_ATTACK_TIME);
const float release_time_ms =
(float)obs_data_get_int(s, S_RELEASE_TIME);
const float output_gain_db =
(float)obs_data_get_double(s, S_OUTPUT_GAIN);
cd->ratio = (float)obs_data_get_double(s, S_RATIO);
cd->threshold = (float)obs_data_get_double(s, S_THRESHOLD);
cd->attack_gain = gain_coefficient(sample_rate,
attack_time_ms / MS_IN_S_F);
cd->release_gain = gain_coefficient(sample_rate,
release_time_ms / MS_IN_S_F);
cd->output_gain = db_to_mul(output_gain_db);
cd->num_channels = num_channels;
cd->sample_rate = sample_rate;
cd->slope = 1.0f - cd->ratio;
const char *detect_mode = obs_data_get_string(s, S_DETECTOR);
if (strcmp(detect_mode, "RMS") == 0)
cd->detector = RMS_DETECT;
if (strcmp(detect_mode, "peak") == 0)
cd->detector = PEAK_DETECT;
if (strcmp(detect_mode, "none") == 0)
cd->detector = NO_DETECT;
size_t sample_len = sample_rate * DEFAULT_AUDIO_BUF_MS / MS_IN_S;
if (cd->envelope_buf_len == 0)
resize_env_buffer(cd, sample_len);
if (cd->runaverage_len == 0)
resize_runaverage_buffer(cd, sample_len);
if (cd->maxspl_len == 0)
resize_maxspl_buffer(cd, sample_len);
if (cd->env_in_len == 0)
resize_env_in_buffer(cd, sample_len);
}
static void ffmpeg_source_update(void *data, obs_data_t *settings)
{
struct ffmpeg_source *s = data;
bool is_local_file = obs_data_get_bool(settings, "is_local_file");
char *input;
char *input_format;
bfree(s->input);
bfree(s->input_format);
if (is_local_file) {
input = (char *)obs_data_get_string(settings, "local_file");
input_format = NULL;
s->is_looping = obs_data_get_bool(settings, "looping");
s->close_when_inactive = obs_data_get_bool(settings,
"close_when_inactive");
obs_source_set_async_unbuffered(s->source, true);
} else {
input = (char *)obs_data_get_string(settings, "input");
input_format = (char *)obs_data_get_string(settings,
"input_format");
s->is_looping = false;
s->close_when_inactive = true;
obs_source_set_async_unbuffered(s->source, false);
}
s->input = input ? bstrdup(input) : NULL;
s->input_format = input_format ? bstrdup(input_format) : NULL;
#ifndef __APPLE__
s->is_hw_decoding = obs_data_get_bool(settings, "hw_decode");
#endif
s->is_clear_on_media_end = obs_data_get_bool(settings,
"clear_on_media_end");
s->restart_on_activate = obs_data_get_bool(settings,
"restart_on_activate");
s->range = (enum video_range_type)obs_data_get_int(settings,
"color_range");
s->buffering_mb = (int)obs_data_get_int(settings, "buffering_mb");
s->is_local_file = is_local_file;
if (s->media_valid) {
mp_media_free(&s->media);
s->media_valid = false;
}
bool active = obs_source_active(s->source);
if (!s->close_when_inactive || active)
ffmpeg_source_open(s);
dump_source_info(s, input, input_format);
if (!s->restart_on_activate || active)
ffmpeg_source_start(s);
}
void BrowserSource::UpdateSettings(obs_data_t *settings)
{
isLocalFile = obs_data_get_bool(settings, "is_local_file");
url = obs_data_get_string(settings, isLocalFile ? "local_file" : "url");
css = obs_data_get_string(settings, "css");
width = (uint32_t)obs_data_get_int(settings, "width");
height = (uint32_t)obs_data_get_int(settings, "height");
fps = (uint32_t)obs_data_get_int(settings, "fps");
shutdown = obs_data_get_bool(settings, "shutdown");
UpdateBrowser();
}
static bool init_connect(struct rtmp_stream *stream)
{
obs_service_t *service;
obs_data_t *settings;
const char *bind_ip;
int64_t drop_p;
int64_t drop_b;
if (stopping(stream)) {
pthread_join(stream->send_thread, NULL);
}
free_packets(stream);
service = obs_output_get_service(stream->output);
if (!service)
return false;
os_atomic_set_bool(&stream->disconnected, false);
stream->total_bytes_sent = 0;
stream->dropped_frames = 0;
stream->min_priority = 0;
settings = obs_output_get_settings(stream->output);
dstr_copy(&stream->path, obs_service_get_url(service));
dstr_copy(&stream->key, obs_service_get_key(service));
dstr_copy(&stream->username, obs_service_get_username(service));
dstr_copy(&stream->password, obs_service_get_password(service));
dstr_depad(&stream->path);
dstr_depad(&stream->key);
drop_b = (int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD);
drop_p = (int64_t)obs_data_get_int(settings, OPT_PFRAME_DROP_THRESHOLD);
stream->max_shutdown_time_sec =
(int)obs_data_get_int(settings, OPT_MAX_SHUTDOWN_TIME_SEC);
if (drop_p < (drop_b + 200))
drop_p = drop_b + 200;
stream->drop_threshold_usec = 1000 * drop_b;
stream->pframe_drop_threshold_usec = 1000 * drop_p;
bind_ip = obs_data_get_string(settings, OPT_BIND_IP);
dstr_copy(&stream->bind_ip, bind_ip);
stream->new_socket_loop = obs_data_get_bool(settings,
OPT_NEWSOCKETLOOP_ENABLED);
stream->low_latency_mode = obs_data_get_bool(settings,
OPT_LOWLATENCY_ENABLED);
obs_data_release(settings);
return true;
}
static bool rtmp_stream_start(void *data)
{
struct rtmp_stream *stream = data;
obs_service_t *service = obs_output_get_service(stream->output);
obs_data_t *settings;
if (!obs_output_can_begin_data_capture(stream->output, 0))
return false;
if (!obs_output_initialize_encoders(stream->output, 0))
return false;
stream->total_bytes_sent = 0;
stream->dropped_frames = 0;
settings = obs_output_get_settings(stream->output);
dstr_copy(&stream->path, obs_service_get_url(service));
dstr_copy(&stream->key, obs_service_get_key(service));
dstr_copy(&stream->username, obs_service_get_username(service));
dstr_copy(&stream->password, obs_service_get_password(service));
stream->drop_threshold_usec =
(int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD) * 1000;
obs_data_release(settings);
return pthread_create(&stream->connect_thread, NULL, connect_thread,
stream) == 0;
}
/**
* The x server was changed
*/
static bool xshm_server_changed(obs_properties_t *props,
obs_property_t *p, obs_data_t *settings)
{
UNUSED_PARAMETER(p);
bool advanced = obs_data_get_bool(settings, "advanced");
int_fast32_t old_screen = obs_data_get_int(settings, "screen");
const char *server = obs_data_get_string(settings, "server");
obs_property_t *screens = obs_properties_get(props, "screen");
/* we want a real NULL here in case there is no string here */
server = (advanced && *server) ? server : NULL;
obs_property_list_clear(screens);
Display *dpy = XOpenDisplay(server);
if (!dpy) {
obs_property_set_enabled(screens, false);
return true;
}
struct dstr screen_info;
dstr_init(&screen_info);
bool xinerama = xinerama_is_active(dpy);
int_fast32_t count = (xinerama) ?
xinerama_screen_count(dpy) : XScreenCount(dpy);
for (int_fast32_t i = 0; i < count; ++i) {
int_fast32_t x, y, w, h;
x = y = w = h = 0;
if (xinerama)
xinerama_screen_geo(dpy, i, &x, &y, &w, &h);
else
x11_screen_geo(dpy, i, &w, &h);
dstr_printf(&screen_info, "Screen %"PRIuFAST32" (%"PRIuFAST32
"x%"PRIuFAST32" @ %"PRIuFAST32
",%"PRIuFAST32")", i, w, h, x, y);
obs_property_list_add_int(screens, screen_info.array, i);
}
/* handle missing screen */
if (old_screen + 1 > count) {
dstr_printf(&screen_info, "Screen %"PRIuFAST32" (not found)",
old_screen);
size_t index = obs_property_list_add_int(screens,
screen_info.array, old_screen);
obs_property_list_item_disable(screens, index, true);
}
dstr_free(&screen_info);
XCloseDisplay(dpy);
obs_property_set_enabled(screens, true);
return true;
}
/*
* Format selected callback
*/
static bool format_selected(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings)
{
UNUSED_PARAMETER(p);
int dev = v4l2_open(obs_data_get_string(settings, "device_id"),
O_RDWR | O_NONBLOCK);
if (dev == -1)
return false;
int input = (int) obs_data_get_int(settings, "input");
uint32_t caps = 0;
if (v4l2_get_input_caps(dev, input, &caps) < 0)
return false;
caps &= V4L2_IN_CAP_STD | V4L2_IN_CAP_DV_TIMINGS;
obs_property_t *resolution = obs_properties_get(props, "resolution");
obs_property_t *framerate = obs_properties_get(props, "framerate");
obs_property_t *standard = obs_properties_get(props, "standard");
obs_property_t *dv_timing = obs_properties_get(props, "dv_timing");
obs_property_set_visible(resolution, (!caps) ? true : false);
obs_property_set_visible(framerate, (!caps) ? true : false);
obs_property_set_visible(standard,
(caps & V4L2_IN_CAP_STD) ? true : false);
obs_property_set_visible(dv_timing,
(caps & V4L2_IN_CAP_DV_TIMINGS) ? true : false);
if (!caps) {
v4l2_resolution_list(dev, obs_data_get_int(
settings, "pixelformat"), resolution);
}
if (caps & V4L2_IN_CAP_STD)
v4l2_standard_list(dev, standard);
if (caps & V4L2_IN_CAP_DV_TIMINGS)
v4l2_dv_timing_list(dev, dv_timing);
v4l2_close(dev);
if (!caps)
obs_property_modified(resolution, settings);
if (caps & V4L2_IN_CAP_STD)
obs_property_modified(standard, settings);
if (caps & V4L2_IN_CAP_DV_TIMINGS)
obs_property_modified(dv_timing, settings);
return true;
}
static void scene_load_item(struct obs_scene *scene, obs_data_t *item_data)
{
const char *name = obs_data_get_string(item_data, "name");
obs_source_t *source = obs_get_source_by_name(name);
struct obs_scene_item *item;
bool visible;
if (!source) {
blog(LOG_WARNING, "[scene_load_item] Source %s not found!",
name);
return;
}
item = obs_scene_add(scene, source);
if (!item) {
blog(LOG_WARNING, "[scene_load_item] Could not add source '%s' "
"to scene '%s'!",
name, obs_source_get_name(scene->source));
obs_source_release(source);
return;
}
obs_data_set_default_int(item_data, "align",
OBS_ALIGN_TOP | OBS_ALIGN_LEFT);
item->rot = (float)obs_data_get_double(item_data, "rot");
item->align = (uint32_t)obs_data_get_int(item_data, "align");
visible = obs_data_get_bool(item_data, "visible");
obs_data_get_vec2(item_data, "pos", &item->pos);
obs_data_get_vec2(item_data, "scale", &item->scale);
set_visibility(item, visible);
item->bounds_type =
(enum obs_bounds_type)obs_data_get_int(item_data,
"bounds_type");
item->bounds_align =
(uint32_t)obs_data_get_int(item_data, "bounds_align");
obs_data_get_vec2(item_data, "bounds", &item->bounds);
obs_source_release(source);
update_item_transform(item);
}
static inline void update_settings(struct monitor_capture *capture,
obs_data_t *settings)
{
capture->monitor = (int)obs_data_get_int(settings, "monitor");
capture->capture_cursor = obs_data_get_bool(settings, "capture_cursor");
capture->compatibility = obs_data_get_bool(settings, "compatibility");
dc_capture_free(&capture->data);
update_monitor(capture, settings);
}
static void decklink_update(void *data, obs_data_t *settings)
{
DeckLink *decklink = (DeckLink *)data;
const char *hash = obs_data_get_string(settings, DEVICE_HASH);
long long id = obs_data_get_int(settings, MODE_ID);
BMDPixelFormat pixelFormat = (BMDPixelFormat)obs_data_get_int(settings,
PIXEL_FORMAT);
speaker_layout channelFormat = (speaker_layout)obs_data_get_int(settings,
CHANNEL_FORMAT);
decklink_enable_buffering(decklink,
obs_data_get_bool(settings, BUFFERING));
ComPtr<DeckLinkDevice> device;
device.Set(deviceEnum->FindByHash(hash));
decklink->SetPixelFormat(pixelFormat);
decklink->SetChannelFormat(channelFormat);
decklink->Activate(device, id);
}
void obs_transition_load(obs_source_t *tr, obs_data_t *data)
{
const char *name = obs_data_get_string(data, "transition_source_a");
int64_t alignment = obs_data_get_int(data, "transition_alignment");
int64_t mode = obs_data_get_int(data, "transition_mode");
int64_t scale_type = obs_data_get_int(data, "transition_scale_type");
int64_t cx = obs_data_get_int(data, "transition_cx");
int64_t cy = obs_data_get_int(data, "transition_cy");
obs_source_t *source = NULL;
if (name) {
source = obs_get_source_by_name(name);
if (source) {
if (!obs_source_add_active_child(tr, source)) {
blog(LOG_WARNING, "Cannot set transition '%s' "
"to source '%s' due to "
"infinite recursion",
tr->context.name, name);
obs_source_release(source);
source = NULL;
}
} else {
blog(LOG_WARNING, "Failed to find source '%s' for "
"transition '%s'",
name, tr->context.name);
}
}
lock_transition(tr);
tr->transition_sources[0] = source;
tr->transition_source_active[0] = true;
tr->transition_alignment = (uint32_t)alignment;
tr->transition_mode = (enum obs_transition_mode)mode;
tr->transition_scale_type = (enum obs_transition_scale_type)scale_type;
tr->transition_cx = (uint32_t)cx;
tr->transition_cy = (uint32_t)cy;
unlock_transition(tr);
recalculate_transition_size(tr);
recalculate_transition_matrices(tr);
}
static void stinger_update(void *data, obs_data_t *settings)
{
struct stinger_info *s = data;
const char *path = obs_data_get_string(settings, "path");
obs_data_t *media_settings = obs_data_create();
obs_data_set_string(media_settings, "local_file", path);
obs_source_release(s->media_source);
s->media_source = obs_source_create_private("ffmpeg_source", NULL,
media_settings);
obs_data_release(media_settings);
int64_t point = obs_data_get_int(settings, "transition_point");
s->transition_point_is_frame =
obs_data_get_int(settings, "tp_type") == TIMING_FRAME;
if (s->transition_point_is_frame)
s->transition_point_frame = (uint64_t)point;
else
s->transition_point_ns = (uint64_t)(point * 1000000LL);
s->monitoring_type = (int)obs_data_get_int(settings,"audio_monitoring");
obs_source_set_monitoring_type(s->media_source, s->monitoring_type);
s->fade_style = (enum fade_style)obs_data_get_int(settings,
"audio_fade_style");
switch (s->fade_style) {
default:
case FADE_STYLE_FADE_OUT_FADE_IN:
s->mix_a = mix_a_fade_in_out;
s->mix_b = mix_b_fade_in_out;
break;
case FADE_STYLE_CROSS_FADE:
s->mix_a = mix_a_cross_fade;
s->mix_b = mix_b_cross_fade;
break;
}
}
/*
* Resolution selected callback
*/
static bool resolution_selected(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings)
{
UNUSED_PARAMETER(p);
int width, height;
int dev = v4l2_open(obs_data_get_string(settings, "device_id"),
O_RDWR | O_NONBLOCK);
if (dev == -1)
return false;
obs_property_t *prop = obs_properties_get(props, "framerate");
v4l2_unpack_tuple(&width, &height, obs_data_get_int(settings,
"resolution"));
v4l2_framerate_list(dev, obs_data_get_int(settings, "pixelformat"),
width, height, prop);
v4l2_close(dev);
obs_property_modified(prop, settings);
return true;
}
void BiLiTextSourcePropertyDlg::OnOpacitySliderChanged(int val)
{
OpacityValLabel->setText(QString("%1%").arg(val * 100 / 255));
obs_data_t *settings = obs_source_get_settings(mSrc);
int color = obs_data_get_int(settings, "color1");
val = (color & 0x00FFFFFF) | (val << 24);
obs_data_set_int(settings, "color1", val);
obs_data_set_int(settings, "color2", val);
obs_source_update(mSrc, settings);
obs_data_release(settings);
}
/**
* Update the capture with changed settings
*/
static void xshm_update(void *vptr, obs_data_t *settings)
{
XSHM_DATA(vptr);
xshm_capture_stop(data);
data->screen_id = obs_data_get_int(settings, "screen");
data->show_cursor = obs_data_get_bool(settings, "show_cursor");
data->advanced = obs_data_get_bool(settings, "advanced");
data->server = bstrdup(obs_data_get_string(settings, "server"));
xshm_capture_start(data);
}
static bool newer_than_cache(void *param, obs_data_t *cache_file)
{
struct file_update_data *input = param;
const char *name = obs_data_get_string(cache_file, "name");
int version = (int)obs_data_get_int(cache_file, "version");
if (strcmp(input->name, name) == 0) {
input->found = true;
input->newer = input->version > version;
return false;
}
return true;
}
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;
}
static bool update_files_to_local(void *param, obs_data_t *local_file)
{
struct update_info *info = param;
struct file_update_data data = {
.name = obs_data_get_string(local_file, "name"),
.version = (int)obs_data_get_int(local_file, "version")
};
enum_files(info->cache_package, newer_than_cache, &data);
if (data.newer || !data.found)
copy_local_to_cache(info, data.name);
return true;
}
static int update_local_version(struct update_info *info)
{
int local_version;
int cache_version = 0;
local_version = (int)obs_data_get_int(info->local_package, "version");
cache_version = (int)obs_data_get_int(info->cache_package, "version");
/* if local cached version is out of date, copy new version */
if (cache_version < local_version) {
enum_files(info->local_package, update_files_to_local, info);
copy_local_to_cache(info, "package.json");
obs_data_release(info->cache_package);
obs_data_addref(info->local_package);
info->cache_package = info->local_package;
return local_version;
}
return cache_version;
}
static inline void key_settings_update(
struct color_key_filter_data *filter, obs_data_t *settings)
{
int64_t similarity = obs_data_get_int(settings, SETTING_SIMILARITY);
int64_t smoothness = obs_data_get_int(settings, SETTING_SMOOTHNESS);
uint32_t key_color = (uint32_t)obs_data_get_int(settings,
SETTING_KEY_COLOR);
const char *key_type = obs_data_get_string(settings,
SETTING_COLOR_TYPE);
if (strcmp(key_type, "green") == 0)
key_color = 0x00FF00;
else if (strcmp(key_type, "blue") == 0)
key_color = 0xFF0000;
else if (strcmp(key_type, "red") == 0)
key_color = 0x0000FF;
else if (strcmp(key_type, "magenta") == 0)
key_color = 0xFF00FF;
vec4_from_rgba(&filter->key_color, key_color | 0xFF000000);
filter->similarity = (float)similarity / 1000.0f;
filter->smoothness = (float)smoothness / 1000.0f;
}
static void crop_filter_update(void *data, obs_data_t *settings)
{
struct crop_filter_data *filter = data;
filter->absolute = !obs_data_get_bool(settings, "relative");
filter->left = (int)obs_data_get_int(settings, "left");
filter->top = (int)obs_data_get_int(settings, "top");
filter->right = (int)obs_data_get_int(settings, "right");
filter->bottom = (int)obs_data_get_int(settings, "bottom");
filter->abs_cx = (int)obs_data_get_int(settings, "cx");
filter->abs_cy = (int)obs_data_get_int(settings, "cy");
}
static void add_video_encoder_params(struct ffmpeg_muxer *stream,
struct dstr *cmd, obs_encoder_t *vencoder)
{
obs_data_t *settings = obs_encoder_get_settings(vencoder);
int bitrate = (int)obs_data_get_int(settings, "bitrate");
video_t *video = obs_get_video();
const struct video_output_info *info = video_output_get_info(video);
obs_data_release(settings);
dstr_catf(cmd, "%s %d %d %d %d %d ",
"h264",
bitrate,
obs_output_get_width(stream->output),
obs_output_get_height(stream->output),
(int)info->fps_num,
(int)info->fps_den);
}
static void update_monitor(struct monitor_capture *capture,
obs_data_t *settings)
{
struct monitor_info monitor = {0};
uint32_t width, height;
monitor.desired_id = (int)obs_data_get_int(settings, "monitor");
EnumDisplayMonitors(NULL, NULL, enum_monitor, (LPARAM)&monitor);
capture->monitor = monitor.id;
width = monitor.rect.right - monitor.rect.left;
height = monitor.rect.bottom - monitor.rect.top;
dc_capture_init(&capture->data, monitor.rect.left, monitor.rect.top,
width, height, capture->capture_cursor,
capture->compatibility);
}
static inline void update_settings(struct duplicator_capture *capture,
obs_data_t *settings)
{
capture->monitor = (int)obs_data_get_int(settings, "monitor");
capture->capture_cursor = obs_data_get_bool(settings, "capture_cursor");
obs_enter_graphics();
gs_duplicator_destroy(capture->duplicator);
capture->duplicator = gs_duplicator_create(capture->monitor);
capture->width = 0;
capture->height = 0;
capture->x = 0;
capture->y = 0;
capture->rot = 0;
capture->reset_timeout = 0.0f;
obs_leave_graphics();
}
static bool confirm_service_file(void *param, struct file_download_data *file)
{
if (astrcmpi(file->name, "services.json") == 0) {
obs_data_t *data;
int format_version;
data = obs_data_create_from_json((char*)file->buffer.array);
if (!data)
return false;
format_version = (int)obs_data_get_int(data, "format_version");
obs_data_release(data);
if (format_version != RTMP_SERVICES_FORMAT_VERSION)
return false;
}
UNUSED_PARAMETER(param);
return true;
}
static void add_audio_encoder_params(struct dstr *cmd, obs_encoder_t *aencoder)
{
obs_data_t *settings = obs_encoder_get_settings(aencoder);
int bitrate = (int)obs_data_get_int(settings, "bitrate");
audio_t *audio = obs_get_audio();
struct dstr name = {0};
obs_data_release(settings);
dstr_copy(&name, obs_encoder_get_name(aencoder));
dstr_replace(&name, "\"", "\"\"");
dstr_catf(cmd, "\"%s\" %d %d %d ",
name.array,
bitrate,
(int)obs_encoder_get_sample_rate(aencoder),
(int)audio_output_get_channels(audio));
dstr_free(&name);
}