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(); } }