obs-studio/plugins/rtmp-services/rtmp-common.c
jp9000 1c5a071eb8 rtmp-services: Add "Show all services" option
I made the rather tough call of not showing all services by default; I
didn't want to have to do this, but too many services are asking to be
put in to the program, and any time I add a service in to the list, I
feel uncomfortable because I feel like I'm potentially advertising them,
and/or they're using our program to advertise as well.  Some of these
services are particularly bad at policing illegal/copyrighted content,
host content that I personally find distasteful or incredibly stupid
(what the heck is up with these "vaping" streams?), or are just fairly
terrible websites in general that I just feel uncomfortable with showing
by default.

However, I do not really want to reject anyone either, I want to let
their users be able to use our program with relative ease, but more than
anything I just simple don't want to be seen as "endorsing" some of
these websites (more than others in particular).  I know that a "show
all services" checkbox is probably pretty pointless/superfluous thing to
do, but I feel like it's at the very least a means of saying "hey, I
don't really endorse these guys," or "use at your own risk," or
"warning: this website is incredibly terrible."

Honestly, I couldn't really think of any better solution that would
 a.) still list all services without outright censoring them, and
 b.) prevent us from being seen as "endorsing" all services.

(Although maybe this whole thing feels a bit.. passive aggressive.  I
feel like I'm tipping over someone's garden gnome in the middle of the
night while they're sleeping.  Still, it's something.)

NOTE: This code is backward compatible; i.e., if you previously had a
service selected that's not common but don't have the "show all"
checkbox checked, it'll still show that service for convenience.
2015-08-16 08:08:13 -07:00

369 lines
9 KiB
C

#include <util/platform.h>
#include <obs-module.h>
#include <jansson.h>
struct rtmp_common {
char *service;
char *server;
char *key;
};
static const char *rtmp_common_getname(void)
{
return obs_module_text("StreamingServices");
}
static void rtmp_common_update(void *data, obs_data_t *settings)
{
struct rtmp_common *service = data;
bfree(service->service);
bfree(service->server);
bfree(service->key);
service->service = bstrdup(obs_data_get_string(settings, "service"));
service->server = bstrdup(obs_data_get_string(settings, "server"));
service->key = bstrdup(obs_data_get_string(settings, "key"));
}
static void rtmp_common_destroy(void *data)
{
struct rtmp_common *service = data;
bfree(service->service);
bfree(service->server);
bfree(service->key);
bfree(service);
}
static void *rtmp_common_create(obs_data_t *settings, obs_service_t *service)
{
struct rtmp_common *data = bzalloc(sizeof(struct rtmp_common));
rtmp_common_update(data, settings);
UNUSED_PARAMETER(service);
return data;
}
static inline const char *get_string_val(json_t *service, const char *key)
{
json_t *str_val = json_object_get(service, key);
if (!str_val || !json_is_string(str_val))
return NULL;
return json_string_value(str_val);
}
static inline bool get_bool_val(json_t *service, const char *key)
{
json_t *bool_val = json_object_get(service, key);
if (!bool_val || !json_is_boolean(bool_val))
return NULL;
return json_is_true(bool_val);
}
static void add_service(obs_property_t *list, json_t *service, bool show_all,
const char *cur_service)
{
json_t *servers;
const char *name;
bool common;
if (!json_is_object(service)) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"is not an object");
return;
}
name = get_string_val(service, "name");
if (!name) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"has no name");
return;
}
common = get_bool_val(service, "common");
if (!show_all && !common && strcmp(cur_service, name) != 0) {
return;
}
servers = json_object_get(service, "servers");
if (!servers || !json_is_array(servers)) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"'%s' has no servers", name);
return;
}
obs_property_list_add_string(list, name, name);
}
static void add_services(obs_property_t *list, json_t *root, bool show_all,
const char *cur_service)
{
json_t *service;
size_t index;
if (!json_is_array(root)) {
blog(LOG_WARNING, "rtmp-common.c: [add_services] JSON file "
"root is not an array");
return;
}
json_array_foreach (root, index, service) {
add_service(list, service, show_all, cur_service);
}
}
static json_t *open_json_file(const char *file)
{
char *file_data = os_quick_read_utf8_file(file);
json_error_t error;
json_t *root;
if (!file_data)
return NULL;
root = json_loads(file_data, JSON_REJECT_DUPLICATES, &error);
bfree(file_data);
if (!root) {
blog(LOG_WARNING, "rtmp-common.c: [open_json_file] "
"Error reading JSON file (%d): %s",
error.line, error.text);
return NULL;
}
return root;
}
static void build_service_list(obs_property_t *list, json_t *root,
bool show_all, const char *cur_service)
{
obs_property_list_clear(list);
add_services(list, root, show_all, cur_service);
}
static void properties_data_destroy(void *data)
{
json_t *root = data;
if (root)
json_decref(root);
}
static void fill_servers(obs_property_t *servers_prop, json_t *service,
const char *name)
{
json_t *servers, *server;
size_t index;
obs_property_list_clear(servers_prop);
servers = json_object_get(service, "servers");
if (!json_is_array(servers)) {
blog(LOG_WARNING, "rtmp-common.c: [fill_servers] "
"Servers for service '%s' not a valid object",
name);
return;
}
json_array_foreach (servers, index, server) {
const char *server_name = get_string_val(server, "name");
const char *url = get_string_val(server, "url");
if (!server_name || !url)
continue;
obs_property_list_add_string(servers_prop, server_name, url);
}
}
static inline json_t *find_service(json_t *root, const char *name)
{
size_t index;
json_t *service;
json_array_foreach (root, index, service) {
const char *cur_name = get_string_val(service, "name");
if (strcmp(name, cur_name) == 0)
return service;
}
return NULL;
}
static bool service_selected(obs_properties_t *props, obs_property_t *p,
obs_data_t *settings)
{
const char *name = obs_data_get_string(settings, "service");
json_t *root = obs_properties_get_param(props);
json_t *service;
if (!name || !*name)
return false;
service = find_service(root, name);
if (!service)
return false;
fill_servers(obs_properties_get(props, "server"), service, name);
UNUSED_PARAMETER(p);
return true;
}
static bool show_all_services_toggled(obs_properties_t *ppts,
obs_property_t *p, obs_data_t *settings)
{
const char *cur_service = obs_data_get_string(settings, "service");
bool show_all = obs_data_get_bool(settings, "show_all");
json_t *root = obs_properties_get_param(ppts);
if (!root)
return false;
build_service_list(obs_properties_get(ppts, "service"), root, show_all,
cur_service);
UNUSED_PARAMETER(p);
return true;
}
static obs_properties_t *rtmp_common_properties(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *ppts = obs_properties_create();
obs_property_t *p;
char *file;
file = obs_module_file("services.json");
if (file) {
json_t *root = open_json_file(file);
obs_properties_set_param(ppts, root, properties_data_destroy);
bfree(file);
}
p = obs_properties_add_list(ppts, "service",
obs_module_text("Service"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback(p, service_selected);
p = obs_properties_add_bool(ppts, "show_all",
obs_module_text("ShowAll"));
obs_property_set_modified_callback(p, show_all_services_toggled);
obs_properties_add_list(ppts, "server", obs_module_text("Server"),
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_properties_add_text(ppts, "key", obs_module_text("StreamKey"),
OBS_TEXT_PASSWORD);
return ppts;
}
static void apply_video_encoder_settings(obs_data_t *settings,
json_t *recommended)
{
json_t *item = json_object_get(recommended, "keyint");
if (item && json_is_integer(item)) {
int keyint = (int)json_integer_value(item);
obs_data_set_int(settings, "keyint_sec", keyint);
}
obs_data_set_bool(settings, "cbr", true);
item = json_object_get(recommended, "profile");
if (item && json_is_string(item)) {
const char *profile = json_string_value(item);
obs_data_set_string(settings, "profile", profile);
}
item = json_object_get(recommended, "max video bitrate");
if (item && json_is_integer(item)) {
int max_bitrate = (int)json_integer_value(item);
if (obs_data_get_int(settings, "bitrate") > max_bitrate) {
obs_data_set_int(settings, "bitrate", max_bitrate);
obs_data_set_int(settings, "buffer_size", max_bitrate);
}
}
}
static void apply_audio_encoder_settings(obs_data_t *settings,
json_t *recommended)
{
json_t *item = json_object_get(recommended, "max audio bitrate");
if (item && json_is_integer(item)) {
int max_bitrate = (int)json_integer_value(item);
if (obs_data_get_int(settings, "bitrate") > max_bitrate)
obs_data_set_int(settings, "bitrate", max_bitrate);
}
}
static void initialize_output(struct rtmp_common *service, json_t *root,
obs_data_t *video_settings, obs_data_t *audio_settings)
{
json_t *json_service = find_service(root, service->service);
json_t *recommended;
if (!json_service) {
blog(LOG_WARNING, "rtmp-common.c: [initialize_output] "
"Could not find service '%s'",
service->service);
return;
}
recommended = json_object_get(json_service, "recommended");
if (!recommended)
return;
if (video_settings)
apply_video_encoder_settings(video_settings, recommended);
if (audio_settings)
apply_audio_encoder_settings(audio_settings, recommended);
}
static void rtmp_common_apply_settings(void *data,
obs_data_t *video_settings, obs_data_t *audio_settings)
{
struct rtmp_common *service = data;
char *file;
file = obs_module_file("services.json");
if (file) {
json_t *root = open_json_file(file);
if (root) {
initialize_output(service, root, video_settings,
audio_settings);
json_decref(root);
}
bfree(file);
}
}
static const char *rtmp_common_url(void *data)
{
struct rtmp_common *service = data;
return service->server;
}
static const char *rtmp_common_key(void *data)
{
struct rtmp_common *service = data;
return service->key;
}
struct obs_service_info rtmp_common_service = {
.id = "rtmp_common",
.get_name = rtmp_common_getname,
.create = rtmp_common_create,
.destroy = rtmp_common_destroy,
.update = rtmp_common_update,
.get_properties = rtmp_common_properties,
.get_url = rtmp_common_url,
.get_key = rtmp_common_key,
.apply_encoder_settings = rtmp_common_apply_settings,
};