コード例 #1
0
ファイル: flv-mux.c プロジェクト: Jack0r/obs-studio
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;
}
コード例 #2
0
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");
}
コード例 #3
0
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));
}
コード例 #4
0
void BiLiOBSMainWid::SaveAudioDeviceConfig()
{
	obs_data_t* data = BiliAudioDeviceConfig::Get();
	if (data)
	{
		BiliConfigFile::SaveAudioDeviceConfig(data);
		obs_data_release(data);
	}
}
コード例 #5
0
void BiLiOBSMainWid::LoadFrontendHotkeys()
{
	obs_data_t* frontendHotkeyData = BiliConfigFile::LoadFrontendHotkeys();
	if (frontendHotkeyData)
	{
		BiliFrontendHotkeyConfig::LoadFrontendHotkeys(frontendHotkeyData);
		obs_data_release(frontendHotkeyData);
	}
}
コード例 #6
0
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;
}
コード例 #7
0
ファイル: obs-hotkey.c プロジェクト: Bl00drav3n/obs-studio
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();
}
コード例 #8
0
ファイル: obs-hotkey.c プロジェクト: Bl00drav3n/obs-studio
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);
}
コード例 #9
0
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);
}
コード例 #10
0
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;
}
コード例 #11
0
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;
}
コード例 #12
0
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);
}
コード例 #13
0
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);
}
コード例 #14
0
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);
	}
}
コード例 #15
0
ファイル: v4l2-input.c プロジェクト: Bl00drav3n/obs-studio
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;
}
コード例 #16
0
ファイル: obs-output.c プロジェクト: bootkiller/obs-studio
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;
}
コード例 #17
0
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);
}
コード例 #18
0
ファイル: scripts.cpp プロジェクト: Dead133/obs-studio
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);
}
コード例 #19
0
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);
	}
}
コード例 #20
0
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);
}
コード例 #21
0
ファイル: obs-encoder.c プロジェクト: Bluelich/obs-studio-
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;
}
コード例 #22
0
ファイル: obs-encoder.c プロジェクト: Arkkis/obs-studio
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;
}
コード例 #23
0
ファイル: obs-service.c プロジェクト: skaramicke/obs-studio
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;
}
コード例 #24
0
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);
}
コード例 #25
0
ファイル: obs.c プロジェクト: Lexsus/obs-studio
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));
}
コード例 #26
0
ファイル: obs-source.c プロジェクト: Christicles/obs-studio
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;
}
コード例 #27
0
ファイル: obs-python-module.c プロジェクト: zenny/obs-python
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;
}
コード例 #28
0
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
}
コード例 #29
0
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);
}
コード例 #30
0
ファイル: BiliUIConfigSync.cpp プロジェクト: dourgulf/biliobs
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;
}