static inline double encoder_bitrate(obs_encoder_t *encoder) { obs_data_t *settings = obs_encoder_get_settings(encoder); double bitrate = obs_data_get_double(settings, "bitrate"); obs_data_release(settings); return bitrate; }
void AutoConfig::SaveStreamSettings() { OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow()); /* ---------------------------------- */ /* save service */ const char *service_id = customServer ? "rtmp_custom" : "rtmp_common"; obs_service_t *oldService = main->GetService(); OBSData hotkeyData = obs_hotkeys_save_service(oldService); obs_data_release(hotkeyData); OBSData settings = obs_data_create(); obs_data_release(settings); if (!customServer) obs_data_set_string(settings, "service", serviceName.c_str()); obs_data_set_string(settings, "server", server.c_str()); obs_data_set_string(settings, "key", key.c_str()); OBSService newService = obs_service_create(service_id, "default_service", settings, hotkeyData); obs_service_release(newService); if (!newService) return; main->SetService(newService); main->SaveService(); main->auth = streamPage->auth; if (!!main->auth) main->auth->LoadUI(); /* ---------------------------------- */ /* save stream settings */ config_set_int(main->Config(), "SimpleOutput", "VBitrate", idealBitrate); config_set_string(main->Config(), "SimpleOutput", "StreamEncoder", GetEncoderId(streamingEncoder)); config_remove_value(main->Config(), "SimpleOutput", "UseAdvanced"); }
void BiLiTextSourcePropertyDlg::OnScrollSpeedSliderChanged(int val) { obs_data_t* filterSettings = obs_source_get_settings(scrollFilter); obs_data_set_int(filterSettings, "speed_x", val); obs_source_update(scrollFilter, filterSettings); obs_data_release(filterSettings); ScrollSpeedValLabel->setText(QString("%1%").arg(val)); }
void BiLiOBSMainWid::SaveAudioDeviceConfig() { obs_data_t* data = BiliAudioDeviceConfig::Get(); if (data) { BiliConfigFile::SaveAudioDeviceConfig(data); obs_data_release(data); } }
void BiLiOBSMainWid::LoadFrontendHotkeys() { obs_data_t* frontendHotkeyData = BiliConfigFile::LoadFrontendHotkeys(); if (frontendHotkeyData) { BiliFrontendHotkeyConfig::LoadFrontendHotkeys(frontendHotkeyData); obs_data_release(frontendHotkeyData); } }
static OBSData OpenServiceSettings(std::string &type) { char serviceJsonPath[512]; int ret = GetProfilePath(serviceJsonPath, sizeof(serviceJsonPath), SERVICE_PATH); if (ret <= 0) return OBSData(); OBSData data = obs_data_create_from_json_file_safe(serviceJsonPath, "bak"); obs_data_release(data); obs_data_set_default_string(data, "type", "rtmp_common"); type = obs_data_get_string(data, "type"); OBSData settings = obs_data_get_obj(data, "settings"); obs_data_release(settings); return settings; }
void obs_hotkeys_context_release(struct obs_context_data *context) { if (!lock()) return; context_release_hotkeys(context); context_release_hotkey_pairs(context); obs_data_release(context->hotkey_data); unlock(); }
static inline void load_bindings(obs_hotkey_t *hotkey, obs_data_array_t *data) { const size_t count = obs_data_array_count(data); for (size_t i = 0; i < count; i++) { obs_data_t *item = obs_data_array_item(data, i); load_binding(hotkey, item); obs_data_release(item); } hotkey_signal("hotkey_bindings_changed", hotkey); }
void BiLiTextSourcePropertyDlg::mSltFontComboxChanged(const QString &text) { QFont font = qobject_cast<QFontComboBox *>(sender())->currentFont(); obs_data_t *fontObj = obs_data_create(); obs_data_set_string(fontObj, "face", (font.family()).toUtf8().data()); obs_data_set_string(fontObj, "style", (font.styleName()).toUtf8().data()); obs_data_set_int(fontObj, "size", font.pointSize()); int flags = font.bold() ? OBS_FONT_BOLD : 0; flags |= font.italic() ? OBS_FONT_ITALIC : 0; flags |= font.underline() ? OBS_FONT_UNDERLINE : 0; flags |= font.strikeOut() ? OBS_FONT_STRIKEOUT : 0; obs_data_set_int(fontObj, "flags", flags); obs_data_t *settingFont = obs_source_get_settings(mSrc); obs_data_set_obj(settingFont, "font", fontObj); obs_data_release(fontObj); obs_data_release(settingFont); }
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 OBSSource CreateLabel(const char *name, size_t h) { obs_data_t *settings = obs_data_create(); obs_data_t *font = obs_data_create(); std::string text; text += " "; text += name; text += " "; #if defined(_WIN32) obs_data_set_string(font, "face", "Arial"); #elif defined(__APPLE__) obs_data_set_string(font, "face", "Helvetica"); #else obs_data_set_string(font, "face", "Monospace"); #endif obs_data_set_int(font, "flags", 1); // Bold text obs_data_set_int(font, "size", int(h / 9.81)); obs_data_set_obj(settings, "font", font); obs_data_set_string(settings, "text", text.c_str()); obs_data_set_bool(settings, "outline", false); #ifdef _WIN32 const char *text_source_id = "text_gdiplus"; #else const char *text_source_id = "text_ft2_source"; #endif OBSSource txtSource = obs_source_create_private(text_source_id, name, settings); obs_source_release(txtSource); obs_data_release(font); obs_data_release(settings); return txtSource; }
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); }
static void SaveAudioDevice(const char *name, int channel, obs_data_t *parent) { obs_source_t *source = obs_get_output_source(channel); if (!source) return; obs_data_t *data = obs_save_source(source); obs_data_set_obj(parent, name, data); obs_data_release(data); obs_source_release(source); }
void obs_encoder_destroy(obs_encoder_t encoder) { if (encoder) { pthread_mutex_lock(&obs->data.encoders_mutex); da_erase_item(obs->data.encoders, &encoder); pthread_mutex_unlock(&obs->data.encoders_mutex); encoder->info.destroy(encoder->data); obs_data_release(encoder->settings); bfree(encoder->name); bfree(encoder); } }
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; }
obs_properties_t obs_get_output_properties(const char *id) { const struct obs_output_info *info = find_output(id); if (info && info->properties) { obs_data_t defaults = get_defaults(info); obs_properties_t properties; properties = info->properties(); obs_properties_apply_settings(properties, defaults); obs_data_release(defaults); return properties; } return NULL; }
void AutoConfigStreamPage::LoadServices(bool showAll) { obs_properties_t *props = obs_get_service_properties("rtmp_common"); OBSData settings = obs_data_create(); obs_data_release(settings); obs_data_set_bool(settings, "show_all", showAll); obs_property_t *prop = obs_properties_get(props, "show_all"); obs_property_modified(prop, settings); ui->service->blockSignals(true); ui->service->clear(); QStringList names; obs_property_t *services = obs_properties_get(props, "service"); size_t services_count = obs_property_list_item_count(services); for (size_t i = 0; i < services_count; i++) { const char *name = obs_property_list_item_string(services, i); names.push_back(name); } if (showAll) names.sort(); for (QString &name : names) ui->service->addItem(name); if (!showAll) { ui->service->addItem( QTStr("Basic.AutoConfig.StreamPage.Service.ShowAll"), QVariant((int)ListOpt::ShowAll)); } ui->service->insertItem(0, QTStr("Basic.AutoConfig.StreamPage.Service.Custom"), QVariant((int)ListOpt::Custom)); if (!lastService.isEmpty()) { int idx = ui->service->findText(lastService); if (idx != -1) ui->service->setCurrentIndex(idx); } obs_properties_destroy(props); ui->service->blockSignals(false); }
static void save_script_data(obs_data_t *save_data, bool saving, void *) { if (!saving) return; obs_data_array_t *array = obs_data_array_create(); for (OBSScript &script : scriptData->scripts) { const char *script_path = obs_script_get_path(script); obs_data_t *settings = obs_script_save(script); obs_data_t *obj = obs_data_create(); obs_data_set_string(obj, "path", script_path); obs_data_set_obj(obj, "settings", settings); obs_data_array_push_back(array, obj); obs_data_release(obj); obs_data_release(settings); } obs_data_set_array(save_data, "scripts-tool", array); obs_data_array_release(array); }
void BiLiOBSMainWid::mLoadSceneListOrder(obs_data_array_t *array) { size_t num = obs_data_array_count(array); for (size_t i = 0; i < num; i++) { obs_data_t *data = obs_data_array_item(array, i); const char *name = obs_data_get_string(data, "name"); // UI Secens ListWidget //ReorderItemByName(ui->scenes, name, (int)i); obs_data_release(data); } }
static void LoadAudioDevice(const char *name, int channel, obs_data_t *parent) { obs_data_t *data = obs_data_get_obj(parent, name); if (!data) return; obs_source_t *source = obs_load_source(data); if (source) { obs_set_output_source(channel, source); obs_source_release(source); } obs_data_release(data); }
obs_properties_t *obs_get_encoder_properties(const char *id) { const struct obs_encoder_info *ei = find_encoder(id); if (ei && ei->get_properties) { obs_data_t *defaults = get_defaults(ei); obs_properties_t *properties; properties = ei->get_properties(NULL); obs_properties_apply_settings(properties, defaults); obs_data_release(defaults); return properties; } return NULL; }
obs_properties_t obs_get_encoder_properties(const char *id, const char *locale) { const struct obs_encoder_info *ei = get_encoder_info(id); if (ei && ei->properties) { obs_data_t defaults = get_defaults(ei); obs_properties_t properties; properties = ei->properties(locale); obs_properties_apply_settings(properties, defaults); obs_data_release(defaults); return properties; } return NULL; }
obs_properties_t *obs_get_service_properties(const char *id) { const struct obs_service_info *info = find_service(id); if (info && info->get_properties) { obs_data_t *defaults = get_defaults(info); obs_properties_t *properties; properties = info->get_properties(NULL); obs_properties_apply_settings(properties, defaults); obs_data_release(defaults); return properties; } return NULL; }
int BiLiTextSourcePropertyDlg::acceptSourceProperties() { obs_data_t* settings = obs_source_get_settings(mSrc); WidgetToData(BILI_DATA_FONT(), FontComboBox, settings, "font"); WidgetToData(BILI_DATA_INT(), ColorChangeBtn, settings, "color1"); WidgetToData(BILI_DATA_INT(), ColorChangeBtn, settings, "color2"); WidgetToData(BILI_DATA_STRING(), PlainTextEdit, settings, "text"); WidgetToData(BILI_DATA_BOOL(), FromFileCheckBox, settings, "from_file"); WidgetToData(BILI_DATA_STRING(), FilePathEdit, settings, "text_file"); obs_source_update(mSrc, settings); obs_data_release(settings); WidgetToFilterData(BILI_DATA_DOUBLE(), ScrollSpeedSlider, mSrc, scroll_filter_id, "speed_x"); return (QDialog::Accepted); }
void obs_context_data_free(struct obs_context_data *context) { signal_handler_destroy(context->signals); proc_handler_destroy(context->procs); obs_data_release(context->settings); obs_context_data_remove(context); pthread_mutex_destroy(&context->rename_cache_mutex); bfree(context->name); for (size_t i = 0; i < context->rename_cache.num; i++) bfree(context->rename_cache.array[i]); da_free(context->rename_cache); memset(context, 0, sizeof(*context)); }
obs_properties_t obs_get_source_properties(enum obs_source_type type, const char *id, const char *locale) { const struct obs_source_info *info = get_source_info(type, id); if (info && info->properties) { obs_data_t defaults = get_defaults(info); obs_properties_t properties; properties = info->properties(locale); obs_properties_apply_settings(properties, defaults); obs_data_release(defaults); return properties; } return NULL; }
static void* python_source_create(obs_data_t* settings, obs_source_t* source) { PyGILState_STATE gstate; gstate = PyGILState_Ensure(); // PyRun_SimpleString("libobs.log('python_source_create with python YAYPyRun_SimpleString')"); UNUSED_PARAMETER(source); //Create the new source here obs_data_t* font_obj = obs_data_create(); obs_data_set_default_string(settings, "text","The lazy."); obs_data_release(font_obj); /* obs_register_source(py_module.tmp->src_info); // This creates a new source. obs_source_t* source = obs_get_output_source(0); //gets output source? obs_scene_t* current_scene = obs_scene_from_source(source); char* name = "TESTING"; source = obs_get_source_by_name(name); if(source) { //source already exists, just add to scene obs_scene_add(current_scene,source); } else { source = obs_source_create(OBS_SOURCE_TYPE_INPUT,"python_source",name,NULL); obs_add_source(source); obs_scene_add(current_scene,source); } obs_source_release(source); obs_scene_release(current_scene); */ PyGILState_Release(gstate); return &python_source_info; }
void BiLiOBSMainWid::mSave(const char *file) { SaveScene(); SaveAudioDeviceConfig(); SaveFrontendHotkeys(); mBasicConfig.Save(); #if 0 obs_data_array_t *sceneOrder = mSaveSceneListOrder(); obs_data_t *saveData = GenerateSaveData(sceneOrder); if (!obs_data_save_json_safe(saveData, file, "tmp", "bak")) blog(LOG_ERROR, "Could not save scene data to %s", file); obs_data_release(saveData); obs_data_array_release(sceneOrder); #endif }
template <typename Func> static void EnumSceneCollections(Func &&cb) { char path[512]; os_glob_t *glob; int ret = GetConfigPath(path, sizeof(path), "obs-studio/basic/scenes/*.json"); if (ret <= 0) { blog(LOG_WARNING, "Failed to get config path for scene " "collections"); return; } if (os_glob(path, 0, &glob) != 0) { blog(LOG_WARNING, "Failed to glob scene collections"); return; } for (size_t i = 0; i < glob->gl_pathc; i++) { const char *filePath = glob->gl_pathv[i].path; if (glob->gl_pathv[i].directory) continue; BPtr<char> fileData = os_quick_read_utf8_file(filePath); if (!fileData) continue; obs_data_t *data = obs_data_create_from_json(fileData); std::string name = obs_data_get_string(data, "name"); /* if no name found, use the file name as the name * (this only happens when switching to the new version) */ if (name.empty()) { name = strrchr(filePath, '/') + 1; name.resize(name.size() - 5); } obs_data_release(data); if (!cb(name.c_str(), filePath)) break; } os_globfree(glob); }
void obs_data_set_qfont(obs_data_t* data, const char* name, QFont font){ obs_data_t *fontObj = obs_data_create(); obs_data_set_string(fontObj, "face", (font.family()).toUtf8().data()); obs_data_set_string(fontObj, "style", (font.styleName()).toUtf8().data()); obs_data_set_int(fontObj, "size", font.pointSize()); int flags = font.bold() ? OBS_FONT_BOLD : 0; flags |= font.italic() ? OBS_FONT_ITALIC : 0; flags |= font.underline() ? OBS_FONT_UNDERLINE : 0; flags |= font.strikeOut() ? OBS_FONT_STRIKEOUT : 0; obs_data_set_int(fontObj, "flags", flags); obs_data_set_obj(data, "font", fontObj); obs_data_release(fontObj); return; }