static htsmsg_t *
tvh_codec_audio_get_list_sample_fmts(TVHAudioCodec *self)
{
htsmsg_t *list = NULL, *map = NULL;
const enum AVSampleFormat *sample_fmts = self->sample_fmts;
enum AVSampleFormat f = AV_SAMPLE_FMT_NONE;
const char *f_str = NULL;
int i;
if (sample_fmts && (list = htsmsg_create_list())) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
}
else {
ADD_ENTRY(list, map, s32, f, str, AUTO_STR);
for (i = 0; (f = sample_fmts[i]) != AV_SAMPLE_FMT_NONE; i++) {
if (!(f_str = av_get_sample_fmt_name(f)) ||
!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
break;
}
ADD_ENTRY(list, map, s32, f, str, f_str);
}
}
}
return list;
}
static htsmsg_t *
tvh_codec_audio_get_list_sample_rates(TVHAudioCodec *self)
{
htsmsg_t *list = NULL, *map = NULL;
const int *sample_rates = self->sample_rates;
int r = 0, i;
if (sample_rates && (list = htsmsg_create_list())) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
}
else {
ADD_ENTRY(list, map, s32, r, str, AUTO_STR);
for (i = 0; (r = sample_rates[i]); i++) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
break;
}
ADD_S32_VAL(list, map, r);
}
}
}
return list;
}
static htsmsg_t *
tvh_codec_audio_get_list_channel_layouts(TVHAudioCodec *self)
{
htsmsg_t *list = NULL, *map = NULL;
const uint64_t *channel_layouts = self->channel_layouts;
uint64_t l = 0;
char l_buf[16];
int i;
if (channel_layouts && (list = htsmsg_create_list())) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
}
else {
ADD_ENTRY(list, map, s64, l, str, AUTO_STR);
for (i = 0; (l = channel_layouts[i]); i++) {
if (l < INT64_MAX) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
break;
}
l_buf[0] = '\0';
av_get_channel_layout_string(l_buf, sizeof(l_buf), 0, l);
ADD_ENTRY(list, map, s64, l, str, l_buf);
}
}
}
}
return list;
}
void
tvhlog_end ( void )
{
pthread_mutex_lock(&tvhlog_mutex);
tvhlog_run = 0;
pthread_cond_signal(&tvhlog_cond);
pthread_mutex_unlock(&tvhlog_mutex);
pthread_join(tvhlog_tid, NULL);
free(tvhlog_path);
htsmsg_destroy(tvhlog_debug);
htsmsg_destroy(tvhlog_trace);
}
static void
keyring_clear(void *opaque, prop_event_t event, ...)
{
hts_mutex_lock(&keyring_mutex);
htsmsg_destroy(persistent_keyring);
htsmsg_destroy(temporary_keyring);
persistent_keyring = htsmsg_create_map();
temporary_keyring = htsmsg_create_map();
htsmsg_store_save(persistent_keyring, "keyring");
hts_mutex_unlock(&keyring_mutex);
notify_add(NULL, NOTIFY_WARNING, NULL, 3, _("Rembered passwords erased"));
}
static htsmsg_t *
avt_SetAVTransportURI(http_connection_t *hc, htsmsg_t *args,
const char *myhost, int myport)
{
const char *uri = htsmsg_get_str(args, "CurrentURI");
const char *metaxml = htsmsg_get_str(args, "CurrentURIMetaData");
char errbuf[200];
htsmsg_t *meta;
if(uri == NULL)
return NULL;
if(metaxml == NULL) {
playqueue_play(uri, prop_create_root(NULL), 1);
return NULL;
}
meta = htsmsg_xml_deserialize(strdup(metaxml), errbuf, sizeof(errbuf));
if(meta == NULL) {
TRACE(TRACE_ERROR, "UPNP",
"SetAVTransportURI: Unable to parse metadata -- %s", errbuf);
return NULL;
}
if(play_with_context(uri, meta)) {
// Failed to play from context
// TODO: Fix metadata here
playqueue_play(uri, prop_create_root(NULL), 1);
}
htsmsg_destroy(meta);
return NULL;
}
/*
* Intialise global file manager
*/
void timeshift_init ( void )
{
htsmsg_t *m;
const char *str;
uint32_t u32;
timeshift_filemgr_init();
/* Defaults */
timeshift_enabled = 0; // Disabled
timeshift_ondemand = 0; // Permanent
timeshift_path = NULL; // setting dir
timeshift_unlimited_period = 0;
timeshift_max_period = 3600; // 1Hr
timeshift_unlimited_size = 0;
timeshift_max_size = 10000 * (size_t)1048576; // 10G
/* Load settings */
if ((m = hts_settings_load("timeshift/config"))) {
if (!htsmsg_get_u32(m, "enabled", &u32))
timeshift_enabled = u32 ? 1 : 0;
if (!htsmsg_get_u32(m, "ondemand", &u32))
timeshift_ondemand = u32 ? 1 : 0;
if ((str = htsmsg_get_str(m, "path")))
timeshift_path = strdup(str);
if (!htsmsg_get_u32(m, "unlimited_period", &u32))
timeshift_unlimited_period = u32 ? 1 : 0;
htsmsg_get_u32(m, "max_period", ×hift_max_period);
if (!htsmsg_get_u32(m, "unlimited_size", &u32))
timeshift_unlimited_size = u32 ? 1 : 0;
if (!htsmsg_get_u32(m, "max_size", &u32))
timeshift_max_size = 1048576LL * u32;
htsmsg_destroy(m);
}
}
static htsmsg_t *
codec_profile_audio_class_language_list(void *obj, const char *lang)
{
htsmsg_t *list = htsmsg_create_list();
lang_code_t *lc = (lang_code_t *)lang_codes;
char lc_buf[128];
while (lc->code2b) {
htsmsg_t *map = NULL;
if (!strcmp(lc->code2b, "und")) {
map = htsmsg_create_key_val("", tvh_gettext_lang(lang, N_("Use original")));
}
else {
memset(lc_buf, 0, sizeof(lc_buf));
if (!str_snprintf(lc_buf, sizeof(lc_buf), "%s (%s)", lc->desc, lc->code2b)) {
map = htsmsg_create_key_val(lc->code2b, lc_buf);
}
else {
htsmsg_destroy(list);
list = NULL;
break;
}
}
htsmsg_add_msg(list, NULL, map);
lc++;
}
return list;
}
static void
bookmark_save(void)
{
htsmsg_t *m = prop_tree_to_htsmsg(prop_create(bookmarks, "nodes"));
htsmsg_store_save(m, "bookmarks");
htsmsg_destroy(m);
}
void
bookmarks_init(void)
{
htsmsg_field_t *f;
htsmsg_t *m, *n, *o;
hts_mutex_init(&bookmark_mutex);
bookmarks = prop_create(settings_add_dir(NULL, "Bookmarks", "bookmark", NULL),
"model");
prop_set_int(prop_create(bookmarks, "mayadd"), 1);
prop_subscribe(0,
PROP_TAG_CALLBACK, bookmarks_callback, NULL,
PROP_TAG_ROOT, prop_create(bookmarks, "nodes"),
PROP_TAG_MUTEX, &bookmark_mutex,
NULL);
if((m = htsmsg_store_load("bookmarks")) != NULL) {
n = htsmsg_get_map(m, "nodes");
HTSMSG_FOREACH(f, n) {
if((o = htsmsg_get_map_by_field(f)) == NULL)
continue;
bookmark_load(o);
}
htsmsg_destroy(m);
}
static void
audio_mastervol_init(void)
{
htsmsg_t *m = htsmsg_store_load("audiomixer");
int32_t i32;
prop_t *pa, *mv, *mm;
pa = prop_create(prop_get_global(), "audio");
mv = prop_create(pa, "mastervolume");
mm = prop_create(pa, "mastermute");
prop_set_float_clipping_range(mv, -75, 12);
if(m != NULL && !htsmsg_get_s32(m, "master-volume", &i32))
prop_set_float(mv, (float)i32 / 1000);
prop_set_int(mm, 0);
htsmsg_destroy(m);
prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_CALLBACK_FLOAT, save_matervol, NULL,
PROP_TAG_ROOT, mv,
NULL);
}
void
influxdb_put(const char *id, double value)
{
char url[1024];
cfg_root(root);
const char *urlprefix = cfg_get_str(root, CFG("influxdb", "url"), NULL);
const char *db = cfg_get_str(root, CFG("influxdb", "db"), NULL);
const char *username = cfg_get_str(root, CFG("influxdb", "username"), NULL);
const char *password = cfg_get_str(root, CFG("influxdb", "password"), NULL);
if(urlprefix == NULL || db == NULL || username == NULL || password == NULL)
return;
snprintf(url, sizeof(url), "%s/db/%s/series?u=%s&p=%s",
urlprefix, db, username, password);
htsmsg_t *doc = htsmsg_create_list();
htsmsg_t *item = htsmsg_create_map();
htsmsg_add_str(item, "name", id);
htsmsg_t *columns = htsmsg_create_list();
htsmsg_add_str(columns, NULL, "value");
htsmsg_add_msg(item, "columns", columns);
htsmsg_t *points = htsmsg_create_list();
htsmsg_t *point = htsmsg_create_list();
htsmsg_add_dbl(point, NULL, value);
htsmsg_add_msg(points, NULL, point);
htsmsg_add_msg(item, "points", points);
htsmsg_add_msg(doc, NULL, item);
char *data = htsmsg_json_serialize_to_str(doc, 0);
htsmsg_destroy(doc);
size_t len = strlen(data);
FILE *f = fmemopen(data, len, "r");
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &libsvc_curl_waste_output);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl, CURLOPT_READDATA, (void *)f);
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)len);
CURLcode result = curl_easy_perform(curl);
curl_easy_cleanup(curl);
if(result)
trace(LOG_ERR, "CURL Failed %s error %d", url, result);
fclose(f);
free(data);
}
static void
htsp_msg_destroy(htsp_msg_t *hm)
{
htsmsg_destroy(hm->hm_msg);
if(hm->hm_pb != NULL)
pktbuf_ref_dec(hm->hm_pb);
free(hm);
}
static int
opensub_login(int force, char *errbuf, size_t errlen)
{
hts_mutex_lock(&opensub_mutex);
if(opensub_token == NULL || force) {
htsmsg_t *in = htsmsg_create_list(), *out, *m;
htsmsg_add_str(in, NULL, opensub_username ?: "");
htsmsg_add_str(in, NULL, opensub_password ?: "");
htsmsg_add_str(in, NULL, "en");
htsmsg_add_str(in, NULL, "Showtime v2.9");
TRACE(TRACE_DEBUG, "opensubtitles", "Logging in as user '%s'",
opensub_username);
out = xmlrpc_request(OPENSUB_URL, "LogIn", in, errbuf, errlen);
if(out == NULL) {
hts_mutex_unlock(&opensub_mutex);
return -1;
}
if((m = htsmsg_get_map_in_list(out, 1)) == NULL) {
snprintf(errbuf, errlen, "Malformed response, no parameters");
err:
htsmsg_destroy(out);
hts_mutex_unlock(&opensub_mutex);
return -1;
}
const char *token = htsmsg_get_str(m, "token");
if(token == NULL) {
snprintf(errbuf, errlen, "Malformed response, no token");
goto err;
}
TRACE(TRACE_DEBUG, "opensubtitles", "Login ok, token: %s",
token);
free(opensub_token);
opensub_token = strdup(token);
htsmsg_destroy(out);
}
/**
* Internal log function
*/
static void
tvhlogv(int notify, int severity, const char *subsys, const char *fmt,
va_list ap)
{
char buf[2048];
char buf2[2048];
char t[50];
int l;
struct tm tm;
time_t now;
l = snprintf(buf, sizeof(buf), "%s: ", subsys);
vsnprintf(buf + l, sizeof(buf) - l, fmt, ap);
if(log_debug_to_syslog || severity < LOG_DEBUG)
syslog(severity, "%s", buf);
/**
* Get time (string)
*/
time(&now);
localtime_r(&now, &tm);
strftime(t, sizeof(t), "%b %d %H:%M:%S", &tm);
/**
* Send notification to Comet (Push interface to web-clients)
*/
if(notify) {
htsmsg_t *m;
snprintf(buf2, sizeof(buf2), "%s %s", t, buf);
m = htsmsg_create_map();
htsmsg_add_str(m, "notificationClass", "logmessage");
htsmsg_add_str(m, "logtxt", buf2);
comet_mailbox_add_message(m, severity == LOG_DEBUG);
htsmsg_destroy(m);
}
/**
* Write to stderr
*/
if(log_stderr && (log_debug_to_console || severity < LOG_DEBUG)) {
const char *leveltxt = logtxtmeta[severity][0];
const char *sgr = logtxtmeta[severity][1];
const char *sgroff;
if(!log_decorate) {
sgr = "";
sgroff = "";
} else {
sgroff = "\033[0m";
}
fprintf(stderr, "%s%s [%s]:%s%s\n", sgr, t, leveltxt, buf, sgroff);
}
}
void
notifications_fini(void)
{
hts_mutex_lock(&news_mutex);
htsmsg_store_save(dismissed_news_out, "dismissed_news");
htsmsg_destroy(dismissed_news_out);
dismissed_news_out = NULL;
hts_mutex_unlock(&news_mutex);
}
static void
save_matervol(void *opaque, float value)
{
htsmsg_t *m = htsmsg_create_map();
TRACE(TRACE_DEBUG, "audio", "Master volume set to %f dB", value);
htsmsg_add_s32(m, "master-volume", value * 1000);
htsmsg_store_save(m, "audiomixer");
htsmsg_destroy(m);
}
void
glw_settings_fini(void)
{
setting_destroy(glw_settings.gs_setting_screensaver);
setting_destroy(glw_settings.gs_setting_underscan_v);
setting_destroy(glw_settings.gs_setting_underscan_h);
setting_destroy(glw_settings.gs_setting_size);
setting_destroy(glw_settings.gs_setting_wrap);
prop_destroy(glw_settings.gs_settings);
htsmsg_destroy(glw_settings.gs_settings_store);
}
/*
* Save settings
*/
static void timeshift_conf_class_save ( idnode_t *self )
{
htsmsg_t *m;
timeshift_fixup();
m = htsmsg_create_map();
idnode_save(×hift_conf.idnode, m);
hts_settings_save(m, "timeshift/config");
htsmsg_destroy(m);
}
static void
glw_fini_settings(glw_root_t *gr)
{
prop_unsubscribe(gr->gr_evsub);
setting_destroy(gr->gr_setting_screensaver);
setting_destroy(gr->gr_setting_underscan_v);
setting_destroy(gr->gr_setting_underscan_h);
setting_destroy(gr->gr_setting_size);
prop_destroy(gr->gr_settings);
htsmsg_destroy(gr->gr_settings_store);
free(gr->gr_settings_instance);
}
static int
htsp_login(htsp_connection_t *hc)
{
const void *ch;
size_t chlen;
htsmsg_t *m;
m = htsmsg_create_map();
htsmsg_add_str(m, "clientname", "HTS Showtime");
htsmsg_add_u32(m, "htspversion", 1);
htsmsg_add_str(m, "method", "hello");
if((m = htsp_reqreply(hc, m)) == NULL) {
return -1;
}
if(htsmsg_get_bin(m, "challenge", &ch, &chlen) || chlen != 32) {
htsmsg_destroy(m);
return -1;
}
memcpy(hc->hc_challenge, ch, 32);
htsmsg_destroy(m);
m = htsmsg_create_map();
htsmsg_add_str(m, "method", "login");
htsmsg_add_u32(m, "htspversion", HTSP_PROTO_VERSION);
if((m = htsp_reqreply(hc, m)) == NULL) {
return -1;
}
htsmsg_destroy(m);
return 0;
}
static void
audio_mode_save_settings(audio_mode_t *am)
{
htsmsg_t *m = htsmsg_create_map();
htsmsg_add_u32(m, "phantom_center", am->am_phantom_center);
htsmsg_add_u32(m, "phantom_lfe", am->am_phantom_lfe);
htsmsg_add_u32(m, "small_front", am->am_small_front);
htsmsg_add_u32(m, "force_downmix", am->am_force_downmix);
htsmsg_add_u32(m, "swap_surround", am->am_swap_surround);
htsmsg_add_s32(m, "delay", am->am_audio_delay);
htsmsg_store_save(m, "audio/devices/%s", am->am_id);
htsmsg_destroy(m);
}
static void
jsg_release(js_setting_group_t *jsg)
{
if(atomic_add(&jsg->jsg_refcount, -1) > 1)
return;
if(jsg->jsg_root != NULL)
prop_destroy(jsg->jsg_root);
if(jsg->jsg_store != NULL)
htsmsg_destroy(jsg->jsg_store);
free(jsg->jsg_spath);
free(jsg);
}
/* Set subsys */
static void
tvhlog_set_subsys ( htsmsg_t **c, const char *subsys )
{
uint32_t a;
char *s, *t, *r = NULL;
if (*c)
htsmsg_destroy(*c);
*c = NULL;
if (!subsys)
return;
s = strdup(subsys);
t = strtok_r(s, ",", &r);
while ( t ) {
subsys = NULL;
a = 1;
if (!*t) goto next;
if (t[0] == '+' || t[0] == '-') {
a = t[0] == '+';
t++;
}
if (!strcmp(t, "all")) {
if (*c)
htsmsg_destroy(*c);
*c = NULL;
}
if (!*c)
*c = htsmsg_create_map();
htsmsg_set_u32(*c, t, a);
next:
t = strtok_r(NULL, ",", &r);
}
free(s);
}
static int
api_dvr_autorec_create_by_series
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
dvr_autorec_entry_t *dae;
epg_broadcast_t *e;
htsmsg_t *entries, *entries2 = NULL, *m;
htsmsg_field_t *f;
const char *config_uuid, *s;
int count = 0;
if (!(entries = htsmsg_get_list(args, "entries"))) {
entries = entries2 = api_dvr_entry_create_from_single(args);
if (!entries)
return EINVAL;
}
HTSMSG_FOREACH(f, entries) {
if (!(m = htsmsg_get_map_by_field(f))) continue;
if (!(s = htsmsg_get_str(m, "event_id")))
continue;
config_uuid = htsmsg_get_str(m, "config_uuid");
pthread_mutex_lock(&global_lock);
if ((e = epg_broadcast_find_by_id(strtoll(s, NULL, 10)))) {
dvr_config_t *cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, config_uuid);
if (cfg) {
dae = dvr_autorec_add_series_link(idnode_uuid_as_str(&cfg->dvr_id),
e,
perm->aa_username,
perm->aa_representative,
"Created from EPG query");
if (dae) {
dvr_autorec_save(dae);
dvr_autorec_changed(dae, 1);
}
}
}
pthread_mutex_unlock(&global_lock);
count++;
}
htsmsg_destroy(entries2);
return !count ? EINVAL : 0;
}
static void
save_order(prop_reorder_t *pr)
{
htsmsg_t *out = htsmsg_create_list();
prop_t *p;
if(pr->pr_dst->hp_type == PROP_DIR)
TAILQ_FOREACH(p, &pr->pr_dst->hp_childs, hp_parent_link)
htsmsg_add_str(out, NULL, get_id(p));
htsmsg_store_save(out, pr->pr_store);
if(pr->pr_order)
htsmsg_destroy(pr->pr_order);
pr->pr_order = out;
}
static void
iptv_service_config_save ( service_t *s )
{
mpegts_mux_t *mm = ((mpegts_service_t *)s)->s_dvb_mux;
htsmsg_t *c = htsmsg_create_map();
char ubuf0[UUID_HEX_SIZE];
char ubuf1[UUID_HEX_SIZE];
char ubuf2[UUID_HEX_SIZE];
service_save(s, c);
hts_settings_save(c, "input/iptv/networks/%s/muxes/%s/services/%s",
idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf0),
idnode_uuid_as_str(&mm->mm_id, ubuf1),
idnode_uuid_as_str(&s->s_id, ubuf2));
htsmsg_destroy(c);
}
void
idnode_done(void)
{
idclass_link_t *il;
pthread_cond_signal(&idnode_cond);
pthread_join(idnode_tid, NULL);
pthread_mutex_lock(&idnode_mutex);
htsmsg_destroy(idnode_queue);
idnode_queue = NULL;
pthread_mutex_unlock(&idnode_mutex);
while ((il = RB_FIRST(&idclasses)) != NULL) {
RB_REMOVE(&idclasses, il, link);
free(il);
}
SKEL_FREE(idclasses_skel);
}
void
satip_device_save( satip_device_t *sd )
{
satip_frontend_t *lfe;
htsmsg_t *m, *l;
m = htsmsg_create_map();
idnode_save(&sd->th_id, m);
l = htsmsg_create_map();
TAILQ_FOREACH(lfe, &sd->sd_frontends, sf_link)
satip_frontend_save(lfe, l);
htsmsg_add_msg(m, "frontends", l);
hts_settings_save(m, "input/satip/adapters/%s",
idnode_uuid_as_str(&sd->th_id));
htsmsg_destroy(m);
}
/*
* Intialise global file manager
*/
void timeshift_init ( void )
{
htsmsg_t *m;
timeshift_filemgr_init();
/* Defaults */
memset(×hift_conf, 0, sizeof(timeshift_conf));
timeshift_conf.idnode.in_class = ×hift_conf_class;
timeshift_conf.max_period = 60; // Hr (60mins)
timeshift_conf.max_size = 10000 * (size_t)1048576; // 10G
/* Load settings */
if ((m = hts_settings_load("timeshift/config"))) {
idnode_load(×hift_conf.idnode, m);
htsmsg_destroy(m);
timeshift_fixup();
}
}
