static void
glw_update_sizes(glw_root_t *gr)
{
int val;
int base_size = gr->gr_height / 35; // 35 is just something
val = GLW_CLAMP(base_size + glw_settings.gs_size, 14, 40);
if(gr->gr_current_size != val) {
gr->gr_current_size = val;
prop_set(gr->gr_prop_ui, "size", PROP_SET_INT, val);
glw_text_flush(gr);
glw_icon_flush(gr);
TRACE(TRACE_DEBUG, "GLW", "UI size scale changed to %d", val);
}
val = GLW_CLAMP(gr->gr_base_underscan_h + glw_settings.gs_underscan_h,
0, 100);
if(gr->gr_underscan_h != val) {
prop_set(gr->gr_prop_ui, "underscan_h", PROP_SET_INT, val);
gr->gr_underscan_h = val;
}
val = GLW_CLAMP(gr->gr_base_underscan_v + glw_settings.gs_underscan_v,
0, 100);
if(gr->gr_underscan_v != val) {
prop_set(gr->gr_prop_ui, "underscan_v", PROP_SET_INT, val);
gr->gr_underscan_v = val;
}
}
static void
update_state(plugin_t *pl)
{
int canInstall = 0;
int canUninstall = 0;
int canUpgrade = 0;
int cantUpgrade = 0;
rstr_t *status = NULL;
int version_dep_ok =
pl->pl_app_min_version == NULL ||
parse_version_int(pl->pl_app_min_version) <=
app_get_version_int();
prop_set(pl->pl_status, "minver", PROP_SET_VOID);
pl->pl_new_version_avail = 0;
if(pl->pl_installed == 0) {
if(!version_dep_ok) {
status = _("Not installable");
prop_set(pl->pl_status, "minver", PROP_SET_STRING,
pl->pl_app_min_version);
} else {
status = _("Not installed");
canInstall = 1;
}
} else if(!strcmp(pl->pl_inst_ver ?: "", pl->pl_repo_ver ?: "")) {
status = _("Up to date");
canUninstall = 1;
} else {
static int
library_open(prop_t *page, const char *url, int sync)
{
const char *q;
bmdb_t *b;
prop_t *model = prop_create(page, "model");
url += strlen("library:");
if((q = mystrbegins(url, "albums:")) != NULL) {
b = bmdb_query_create(q, LIBRARY_QUERY_ALBUMS, model);
} else if((q = mystrbegins(url, "album:")) != NULL) {
b = bmdb_query_create(q, LIBRARY_QUERY_ALBUM, model);
prop_set(model, "contents", PROP_SET_STRING, "album");
} else if((q = mystrbegins(url, "artists:")) != NULL) {
b = bmdb_query_create(q, LIBRARY_QUERY_ARTISTS, model);
} else if((q = mystrbegins(url, "artist:")) != NULL) {
b = bmdb_query_create(q, LIBRARY_QUERY_ARTIST, model);
prop_set(model, "contents", PROP_SET_STRING, "artist");
} else {
nav_open_error(page, "Invalid browse URL");
return 0;
}
hts_thread_create_detached("bmdbquery", bmdb_thread, b, THREAD_PRIO_LOW);
return 0;
}
void
device_register(struct device *dev, void *aux)
{
struct device *parent = dev->dv_parent;
if (strcmp(dev->dv_cfdata->cf_name, "com") == 0 &&
strcmp(parent->dv_cfdata->cf_name, "opb") == 0) {
/* Set the frequency of the on-chip UART. */
int freq = COM_FREQ * 6;
if (prop_set(dev_propdb, dev, "frequency",
&freq, sizeof(freq), PROP_INT, 0) != 0)
printf("WARNING: unable to set frequency "
"property for %s\n", dev->dv_xname);
return;
}
if (strcmp(dev->dv_cfdata->cf_name, "emac") == 0 &&
strcmp(parent->dv_cfdata->cf_name, "opb") == 0) {
/* Set the mac-addr of the on-chip Ethernet. */
/* XXX 405GP only has one; what about CPUs with two? */
if (prop_set(dev_propdb, dev, "mac-addr",
&board_data.mac_address_local,
sizeof(board_data.mac_address_local),
PROP_CONST, 0) != 0)
printf("WARNING: unable to set mac-addr "
"property for %s\n", dev->dv_xname);
return;
}
}
void
connman_init(void)
{
TAILQ_INIT(&connman_services);
netconf_model = prop_create_root(NULL);
prop_concat_t *pc = prop_concat_create(prop_create(netconf_model, "nodes"));
net_state = prop_create(netconf_model, "status");
prop_set(netconf_model, "type", PROP_SET_STRING, "directory");
prop_t *m = prop_create(netconf_model, "metadata");
prop_set(m, "title", PROP_SET_RSTRING, _("Network connections"));
// service_nodes contains list of items we receive from connman
service_nodes = prop_create_root(NULL);
prop_concat_add_source(pc, service_nodes, NULL);
// settings
connman_settings = prop_create_root(NULL);
prop_t *delim = prop_create_root(NULL);
prop_set_string(prop_create(delim, "type"), "separator");
prop_concat_add_source(pc, prop_create(connman_settings, "nodes"), delim);
settings_add_url(gconf.settings_network,
_p("Network connections"), NULL, NULL, NULL, MYURL,
SETTINGS_FIRST);
hts_thread_create_detached("connman", connman_thread, NULL,
THREAD_PRIO_BGTASK);
}
HRESULT create_channel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
const WS_CHANNEL_PROPERTY *properties, ULONG count, struct channel **ret )
{
struct channel *channel;
ULONG i, msg_size = 65536;
HRESULT hr;
if (!(channel = alloc_channel())) return E_OUTOFMEMORY;
prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
&msg_size, sizeof(msg_size) );
for (i = 0; i < count; i++)
{
hr = prop_set( channel->prop, channel->prop_count, properties[i].id, properties[i].value,
properties[i].valueSize );
if (hr != S_OK)
{
free_channel( channel );
return hr;
}
}
channel->type = type;
channel->binding = binding;
*ret = channel;
return S_OK;
}
static prop_t *
add_news_locked(const char *id, const char *message,
const char *location, const char *caption,
const char *action)
{
prop_t *p, *ret = NULL;
prop_t *root = prop_create(prop_get_global(), "news");
if(dismissed_news_out != NULL) {
if(htsmsg_get_u32_or_default(dismissed_news_in, id, 0)) {
dismis_news(id);
} else {
p = prop_create_root(id);
prop_set(p, "message", PROP_SET_STRING, message);
prop_set(p, "id", PROP_SET_STRING, id);
prop_set(p, "location", PROP_SET_STRING, location);
prop_set(p, "caption", PROP_SET_STRING, caption);
prop_set(p, "action", PROP_SET_STRING, action);
prop_subscribe(PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, news_sink, prop_ref_inc(p),
PROP_TAG_ROOT, prop_create(p, "eventSink"),
PROP_TAG_MUTEX, &news_mutex,
NULL);
ret = prop_ref_inc(p);
if(prop_set_parent(p, root))
prop_destroy(p);
}
}
return ret;
}
/**
* Set some info in the global property tree that might be interesting
*/
static void
init_global_info(void)
{
prop_t *s = prop_create(prop_get_global(), "app");
extern const char *htsversion;
extern const char *htsversion_full;
prop_set(s, "name", PROP_SET_STRING, APPNAMEUSER);
prop_set(s, "version", PROP_SET_STRING, htsversion);
prop_set(s, "fullversion", PROP_SET_STRING, htsversion_full);
prop_set(s, "copyright", PROP_SET_STRING, "© 2006 - 2015 Lonelycoder AB");
}
/**
* Try to open the given URL with a playqueue context
*/
static int
file_open_audio(prop_t *page, const char *url)
{
char parent[URL_MAX];
char parent2[URL_MAX];
struct fa_stat fs;
prop_t *model;
if(fa_parent(parent, sizeof(parent), url))
return 1;
if(fa_stat(parent, &fs, NULL, 0))
return 1;
model = prop_create(page, "model");
prop_set_string(prop_create(model, "type"), "directory");
/* Find a meaningful page title (last component of URL) */
rstr_t *title = title_from_url(parent);
prop_set(model, "metadata", "title", NULL, PROP_SET_RSTRING, title);
// Set parent
if(!fa_parent(parent2, sizeof(parent2), parent))
prop_set_string(prop_create(page, "parent"), parent2);
fa_scanner(parent, fs.fs_mtime, model, url, prop_create(page, "directClose"),
title);
rstr_release(title);
return 0;
}
void
mp_reset(media_pipe_t *mp)
{
cancellable_reset(mp->mp_cancellable);
prop_set(mp->mp_prop_io, "bitrate", PROP_SET_VOID);
prop_set(mp->mp_prop_io, "bitrateValid", PROP_SET_VOID);
prop_destroy_childs(mp->mp_prop_audio_tracks);
prop_destroy_childs(mp->mp_prop_subtitle_tracks);
prop_set_void(mp->mp_prop_audio_track_current);
mp_add_track_off(mp->mp_prop_subtitle_tracks, "sub:off");
prop_set_string(mp->mp_prop_subtitle_track_current, "sub:off");
}
void
mp_set_duration(media_pipe_t *mp, int64_t duration)
{
if(duration == AV_NOPTS_VALUE) {
mp->mp_duration = 0;
prop_set(mp->mp_prop_metadata, "duration", PROP_SET_VOID);
return;
}
mp->mp_duration = duration;
float d = mp->mp_duration / 1000000.0;
prop_set(mp->mp_prop_metadata, "duration", PROP_SET_FLOAT, d);
if(duration && mp->mp_prop_metadata_source)
prop_set(mp->mp_prop_metadata_source, "duration", PROP_SET_FLOAT, d);
}
static HRESULT create_proxy( WS_CHANNEL *channel, const WS_PROXY_PROPERTY *properties, ULONG count,
WS_SERVICE_PROXY **handle )
{
struct proxy *proxy;
HRESULT hr;
ULONG i;
if (!(proxy = alloc_proxy())) return E_OUTOFMEMORY;
for (i = 0; i < count; i++)
{
hr = prop_set( proxy->prop, proxy->prop_count, properties[i].id, properties[i].value,
properties[i].valueSize );
if (hr != S_OK)
{
free_proxy( proxy );
return hr;
}
}
proxy->channel = channel;
*handle = (WS_SERVICE_PROXY *)proxy;
return S_OK;
}
static void
audio_setup_spdif_muxer(audio_decoder_t *ad, AVCodec *codec,
media_queue_t *mq)
{
AVOutputFormat *ofmt = av_guess_format("spdif", NULL, NULL);
if(ofmt == NULL)
return;
const int mux_buffer_size = 16384;
assert(ad->ad_mux_buffer == NULL);
ad->ad_mux_buffer = malloc(mux_buffer_size);
AVFormatContext *fctx = avformat_alloc_context();
fctx->oformat = ofmt;
fctx->pb = avio_alloc_context(ad->ad_mux_buffer, mux_buffer_size,
1, ad, NULL, spdif_mux_write, NULL);
AVStream *s = avformat_new_stream(fctx, codec);
s->codec->sample_rate = 48000; // ???
if(avcodec_open2(s->codec, codec, NULL)) {
TRACE(TRACE_ERROR, "audio", "Unable to open %s codec for SPDIF",
codec->name);
bad:
av_free(fctx->pb);
free(ad->ad_mux_buffer);
ad->ad_mux_buffer = NULL;
avformat_free_context(fctx);
return;
}
if(avformat_write_header(fctx, NULL)) {
TRACE(TRACE_ERROR, "audio", "Unable to open SPDIF muxer",
codec->name);
goto bad;
}
ad->ad_spdif_muxer = fctx;
TRACE(TRACE_DEBUG, "audio", "SPDIF muxer opened");
const char *name;
switch(codec->id) {
case AV_CODEC_ID_DTS: name = "DTS"; break;
case AV_CODEC_ID_AC3: name = "AC3"; break;
case AV_CODEC_ID_EAC3: name = "EAC3"; break;
default:
name = "";
break;
}
char str[64];
snprintf(str, sizeof(str), "%s%sPass-Through", name, *name ? " " : "");
prop_set_string(mq->mq_prop_codec, str);
ad->ad_in_sample_rate = 0;
ad->ad_in_sample_format = 0;
ad->ad_in_channel_layout = 0;
prop_set(ad->ad_mp->mp_prop_ctrl, "canAdjustVolume", PROP_SET_INT, 0);
}
static JSBool
js_item_disable(JSContext *cx, JSObject *obj,
uintN argc, jsval *argv, jsval *rval)
{
js_item_t *ji = JS_GetPrivate(cx, obj);
prop_set(ji->ji_root, "enabled", PROP_SET_INT, 0);
*rval = JSVAL_VOID;
return JS_TRUE;
}
/**************************************************************************
* WsSetChannelProperty [webservices.@]
*/
HRESULT WINAPI WsSetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, const void *value,
ULONG size, WS_ERROR *error )
{
struct channel *channel = (struct channel *)handle;
TRACE( "%p %u %p %u\n", handle, id, value, size );
if (error) FIXME( "ignoring error parameter\n" );
return prop_set( channel->prop, channel->prop_count, id, value, size );
}
static void
artist_query(bmdb_t *b, void *db)
{
sqlite3_stmt *stmt;
int rc;
int artist_id = atoi(b->b_query);
rc = db_prepare(db, &stmt,
"SELECT title "
"FROM artist "
"WHERE ds_id = 1 "
"AND id = ?1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, artist_id);
if(db_step(stmt) == SQLITE_ROW) {
rstr_t *artist = db_rstr(stmt, 0);
prop_set(b->b_metadata, "title", PROP_SET_RSTRING, artist);
prop_t *p = prop_create_r(b->b_metadata, "artist_images");
metadata_bind_artistpics(p, artist);
prop_ref_dec(p);
rstr_release(artist);
}
sqlite3_finalize(stmt);
rc = db_prepare(db, &stmt,
"SELECT id,title "
"FROM album "
"WHERE ds_id = 1 "
"AND artist_id = ?1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, artist_id);
rstr_t *ct = rstr_alloc("album");
while((rc = db_step(stmt)) == SQLITE_ROW) {
char url[PATH_MAX];
snprintf(url, sizeof(url), "library:album:%d",
sqlite3_column_int(stmt, 0));
add_item(b, url, NULL, ct,
(const char *)sqlite3_column_text(stmt, 1), 0, NULL, 0);
}
rstr_release(ct);
sqlite3_finalize(stmt);
}
void
mp_reset(media_pipe_t *mp)
{
mp_unhold(mp, MP_HOLD_PRE_BUFFERING | MP_HOLD_STREAM | MP_HOLD_SYNC);
cancellable_reset(mp->mp_cancellable);
prop_set(mp->mp_prop_io, "bitrate", PROP_SET_VOID);
prop_set(mp->mp_prop_io, "bitrateValid", PROP_SET_VOID);
prop_t *p = prop_create(mp->mp_prop_io, "infoNodes");
prop_destroy_childs(p);
prop_destroy_childs(mp->mp_prop_audio_tracks);
prop_destroy_childs(mp->mp_prop_subtitle_tracks);
prop_set_void(mp->mp_prop_audio_track_current);
mp_add_track_off(mp->mp_prop_subtitle_tracks, "sub:off");
prop_set_string(mp->mp_prop_subtitle_track_current, "sub:off");
}
static bmdb_t *
bmdb_query_create(const char *query, int type, prop_t *model)
{
bmdb_t *b = calloc(1, sizeof(bmdb_t));
prop_set(model, "type", PROP_SET_STRING, "directory");
b->b_nodes = prop_create_r(model, "nodes");
b->b_metadata = prop_create_r(model, "metadata");
b->b_type = type;
b->b_query = strdup(query);
return b;
}
int property_set(const char *key, const char *value){
static int (*prop_set)(const char *key, const char *value)=0;
if (!prop_set){
void *h = dlopen("libcutils.so",RTLD_LAZY);
if (!h)
return -1;
prop_set = dlsym(h, "property_set");
if (!prop_set)
return -1;
}
return prop_set(key, value);
}
void
runcontrol_init(void)
{
prop_t *rc;
rc = prop_create(prop_get_global(), "runcontrol");
prop_set(rc, "canStandby", PROP_SET_INT, !!gconf.can_standby);
prop_set(rc, "canPowerOff", PROP_SET_INT, !!gconf.can_poweroff);
prop_set(rc, "canLogout", PROP_SET_INT, !!gconf.can_logout);
prop_set(rc, "canOpenShell", PROP_SET_INT, !!gconf.can_open_shell);
prop_set(rc, "canRestart", PROP_SET_INT, !!gconf.can_restart);
prop_set(rc, "canExit", PROP_SET_INT, !gconf.can_not_exit);
if(!(gconf.can_standby ||
gconf.can_poweroff ||
gconf.can_logout ||
gconf.can_open_shell ||
gconf.can_restart ||
!gconf.can_not_exit))
return;
settings_create_separator(gconf.settings_general,
_p("Starting and stopping"));
if(gconf.can_standby) {
init_autostandby();
init_sleeptimer(rc);
settings_create_action(gconf.settings_general, _p("Standby"),
do_standby, NULL, 0, NULL);
}
if(gconf.can_poweroff)
settings_create_action(gconf.settings_general, _p("Power off system"),
do_power_off, NULL, 0, NULL);
if(gconf.can_logout)
settings_create_action(gconf.settings_general, _p("Logout"),
do_logout, NULL, 0, NULL);
if(gconf.can_open_shell)
settings_create_action(gconf.settings_general, _p("Open shell"),
do_open_shell, NULL, 0, NULL);
if(!gconf.can_not_exit)
settings_create_action(gconf.settings_general, _p("Quit"),
do_exit, NULL, 0, NULL);
if(gconf.shell_fd > 0) {
settings_create_separator(gconf.settings_network, _p("SSH server"));
setting_create(SETTING_BOOL, gconf.settings_network,SETTINGS_INITIAL_UPDATE,
SETTING_TITLE(_p("Enable SSH server")),
SETTING_VALUE(0),
SETTING_CALLBACK(set_ssh_server, NULL),
SETTING_STORE("runcontrol", "sshserver"),
NULL);
}
}
static int
meminfo_do(void)
{
int ret = 0;
char data[1000];
uint64_t v1;
char s1[64];
FILE *f;
prop_t *mem = prop_create(p_sys, "mem");
struct mallinfo mi = mallinfo();
prop_set(mem, "arena", PROP_SET_INT, (mi.hblks + mi.arena) / 1024);
prop_set(mem, "unusedChunks", PROP_SET_INT, mi.ordblks);
prop_set(mem, "activeMem", PROP_SET_INT, mi.uordblks / 1024);
prop_set(mem, "inactiveMem", PROP_SET_INT, mi.fordblks / 1024);
f = fopen("/proc/meminfo", "r");
if(f == NULL)
return 0;
while(fgets(data, sizeof(data), f) != NULL) {
if(sscanf(data, "%60s %"PRId64, s1, &v1) != 2)
continue;
if(!strcmp(s1, "MemTotal:"))
prop_set(mem, "systotal", PROP_SET_INT, v1);
else if(!strcmp(s1, "MemFree:"))
prop_set(mem, "sysfree", PROP_SET_INT, v1);
}
fclose(f);
return ret;
}
void
metadata_browse(void *db, const char *url, prop_t *nodes,
prop_t *model,
library_query_t type,
int (*checkstop)(void *opaque), void *opaque)
{
prop_t *status = prop_create_r(model, "status");
bmdb_t b = {0};
b.b_query = strdup(url);
b.b_type = type;
b.b_nodes = nodes;
b.b_metadata = prop_create_r(model, "metadata");
while(!checkstop(opaque)) {
int p = get_percentage(url);
if(p != 100) {
prop_set(model, "percentage", PROP_SET_INT, p);
prop_set(model, "progressmeter", PROP_SET_INT, 1);
prop_link(_p("Indexing"), status);
} else {
prop_set(model, "progressmeter", PROP_SET_INT, 0);
prop_unlink(status);
}
// int64_t ts = showtime_get_ts();
bmdb_query_exec(db, &b);
// printf("Query took %lld\n", showtime_get_ts() - ts);
prop_set(model, "loading", PROP_SET_INT, 0);
sleep(1);
}
prop_set(model, "progressmeter", PROP_SET_INT, 0);
prop_unlink(status);
free(b.b_query);
prop_ref_dec(status);
prop_ref_dec(b.b_metadata);
}
static void
init_sleeptimer(prop_t *rc)
{
const int maxtime = 180;
sleeptime_prop = prop_create(rc, "sleepTime");
prop_set_int(sleeptime_prop, 60);
prop_set_int_clipping_range(sleeptime_prop, 0, maxtime);
prop_set(rc, "sleepTimeMax", PROP_SET_INT, maxtime);
prop_set(rc, "sleepTimeStep", PROP_SET_INT, 5);
sleeptime_sub =
prop_subscribe(0,
PROP_TAG_CALLBACK_INT, update_sleeptime, NULL,
PROP_TAG_ROOT, sleeptime_prop,
NULL);
prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_NAME("global", "runcontrol", "sleepTimer"),
PROP_TAG_CALLBACK_INT, update_sleeptimer, NULL,
NULL);
}
/**
* Popup an request to the user on behalf of connman
*/
static GVariant *
agent_request_input(connman_service_t *cs, GVariant *req,
GDBusMethodInvocation *inv)
{
TRACE(TRACE_INFO, "CONNMAN", "Requesting credentials for %s", cs->cs_path);
TRACE(TRACE_DEBUG, "CONNMAN", "RequestInput: %s",
g_variant_print(req, TRUE));
prop_t *p = prop_create_root(NULL);
prop_set(p, "type", PROP_SET_STRING, "auth");
prop_set(p, "id", PROP_SET_STRING, cs->cs_path);
prop_set(p, "source", PROP_SET_STRING, "Network");
GVariant *prev = g_variant_lookup_value(req, "PreviousPassphrase", NULL);
if(prev) {
prop_set(p, "reason", PROP_SET_STRING, "Password incorrect");
} else {
prop_set(p, "reason", PROP_SET_STRING, "Password needed");
}
GVariant *identity = g_variant_lookup_value(req, "Identity", NULL);
cs->cs_input_req_want_identity = identity != NULL;
prop_set(p, "disableUsername", PROP_SET_INT, !cs->cs_input_req_want_identity);
prop_set(p, "disableDomain", PROP_SET_INT, 1);
prop_t *r = prop_create(p, "eventSink");
cs->cs_input_req_sub =
prop_subscribe(0,
PROP_TAG_CALLBACK_EVENT, input_req_event, cs,
PROP_TAG_NAMED_ROOT, r, "popup",
PROP_TAG_COURIER, connman_courier,
NULL);
cs->cs_input_req_prop = p;
/* Will show the popup */
if(prop_set_parent(p, prop_create(prop_get_global(), "popups"))) {
/* popuproot is a zombie, this is an error */
abort();
}
cs->cs_input_req_inv = inv;
g_object_ref(G_OBJECT(inv));
return NULL;
}
static void
mem_monitor_do(void)
{
int mib[6];
mib[0] = CTL_HW;
mib[1] = HW_PAGESIZE;
int pagesize;
size_t length;
length = sizeof(pagesize);
if(sysctl (mib, 2, &pagesize, &length, NULL, 0) < 0)
return;
mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
vm_statistics_data_t vmstat;
if(host_statistics (mach_host_self (), HOST_VM_INFO,
(host_info_t) &vmstat, &count) != KERN_SUCCESS)
return;
int total =
vmstat.wire_count +
vmstat.active_count +
vmstat.inactive_count +
vmstat.free_count;
prop_t *mem = prop_create(p_sys, "mem");
prop_set(mem, "systotal", PROP_SET_INT, total / 1024 * pagesize);
prop_set(mem, "sysfree", PROP_SET_INT, vmstat.free_count / 1024 * pagesize);
task_basic_info_64_data_t info;
unsigned size = sizeof(info);
task_info(mach_task_self(), TASK_BASIC_INFO_64, (task_info_t) &info, &size);
prop_set(mem, "activeMem", PROP_SET_INT, (int)(info.resident_size / 1024));
}
/* set the values for a property
* ctx -- context from prop_new()/prop_request()
* name -- name of property to which value will be added
* if NULL, add to the same name as previous prop_set/setvals call
* values -- array of values, ending in NULL. Each value is a NUL terminated
* string
*/
int prop_setvals(struct propctx *ctx, const char *name,
const char **values)
{
const char **val = values;
int result = SASL_OK;
if(!ctx) return SASL_BADPARAM;
/* If they want us to add no values, we can do that */
if(!values) return SASL_OK;
/* Basically, use prop_set to do all our dirty work for us */
if(name) {
result = prop_set(ctx, name, *val, 0);
val++;
}
for(;*val;val++) {
if(result != SASL_OK) return result;
result = prop_set(ctx, NULL, *val,0);
}
return result;
}
void
mp_configure(media_pipe_t *mp, int flags, int buffer_size, int64_t duration,
const char *type)
{
hts_mutex_lock(&mp->mp_mutex);
prop_set_string(mp->mp_prop_playstatus, "play");
mp->mp_framerate.num = 0;
mp->mp_framerate.den = 1;
mp->mp_max_realtime_delay = INT32_MAX;
mp_set_clr_flags_locked(mp, flags,
MP_PRE_BUFFERING |
MP_FLUSH_ON_HOLD |
MP_ALWAYS_SATISFIED |
MP_CAN_SEEK |
MP_CAN_PAUSE |
MP_CAN_EJECT);
prop_set(mp->mp_prop_root, "type", PROP_SET_STRING, type);
switch(buffer_size) {
case MP_BUFFER_NONE:
mp->mp_buffer_limit = 0;
break;
case MP_BUFFER_SHALLOW:
mp->mp_buffer_limit = 1 * 1024 * 1024;
break;
case MP_BUFFER_DEEP:
mp->mp_buffer_limit = video_settings.video_buffer_size * 1024 * 1024;
break;
}
prop_set_int(mp->mp_prop_buffer_limit, mp->mp_buffer_limit);
mp_set_duration(mp, duration);
if(mp->mp_clock_setup != NULL)
mp->mp_clock_setup(mp, mp->mp_audio.mq_stream != -1);
if(mp->mp_flags & MP_PRE_BUFFERING)
mp_check_underrun(mp);
hts_mutex_unlock(&mp->mp_mutex);
}
void
device_register(struct device *dev, void *aux)
{
struct cfdata *cf = dev->dv_cfdata;
const char *name = cf->cf_name;
struct aubus_attach_args *aa = aux;
/*
* We don't ever know the boot device. But that's because the
* firmware only loads from the network.
*/
/* Fetch the MAC addresses from YAMON. */
if (strcmp(name, "aumac") == 0) {
uint8_t ethaddr[ETHER_ADDR_LEN];
const char *cp;
char *cp0;
int i;
/* Get the Ethernet address of the first on-board Ethernet. */
#if defined(ETHADDR)
cp = ETHADDR;
#else
cp = yamon_getenv("ethaddr");
#endif
if (cp != NULL) {
for (i = 0; i < ETHER_ADDR_LEN; i++) {
ethaddr[i] = strtoul(cp, &cp0, 16);
cp = cp0 + 1;
}
if (aa->aa_addr != MAC0_BASE &&
aa->aa_addr != AU1500_MAC0_BASE) {
/* XXX
* The PROM has a variable for the MAC address
* of the first interface. For now, just add
* 0x10 to the second last octet(!) for the
* second interface (Linux does the same).
*/
ethaddr[4] += 0x10;
}
if (prop_set(dev_propdb, dev, "mac-addr",
ethaddr, sizeof(ethaddr), 0, 0) != 0) {
printf("WARNING: unable to set mac-addr "
"property for %s\n", dev->dv_xname);
}
}
}
}
static HRESULT create_msg( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle )
{
struct msg *msg;
HRESULT hr;
ULONG i;
if (!(msg = alloc_msg())) return E_OUTOFMEMORY;
for (i = 0; i < count; i++)
{
if (properties[i].id == WS_MESSAGE_PROPERTY_ENVELOPE_VERSION ||
properties[i].id == WS_MESSAGE_PROPERTY_ADDRESSING_VERSION)
{
free_msg( msg );
return E_INVALIDARG;
}
hr = prop_set( msg->prop, msg->prop_count, properties[i].id, properties[i].value,
properties[i].valueSize );
if (hr != S_OK)
{
free_msg( msg );
return hr;
}
}
if ((hr = WsCreateHeap( HEAP_MAX_SIZE, 0, NULL, 0, &msg->heap, NULL )) != S_OK)
{
free_msg( msg );
return hr;
}
if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &msg->buf, NULL )) != S_OK)
{
free_msg( msg );
return hr;
}
UuidCreate( &msg->id );
msg->version_env = env_version;
msg->version_addr = addr_version;
*handle = (WS_MESSAGE *)msg;
return S_OK;
}
static event_t *
sendpkt(rtmp_t *r, media_queue_t *mq, media_codec_t *mc,
int64_t dts, int64_t pts, const void *data,
size_t size, int skip, int dt, int duration, int drive_clock)
{
event_t *e = NULL;
media_buf_t *mb = media_buf_alloc_unlocked(r->mp, size);
if(r->is_loading) {
r->is_loading = 0;
prop_set(r->mp->mp_prop_root, "loading", PROP_SET_INT, 0);
}
mb->mb_data_type = dt;
mb->mb_duration = duration;
mb->mb_cw = media_codec_ref(mc);
mb->mb_drive_clock = drive_clock;
mb->mb_dts = dts;
mb->mb_pts = pts;
mb->mb_user_time = pts;
mb->mb_skip = skip;
memcpy(mb->mb_data, data, size);
do {
if(mb == NULL || (e = mb_enqueue_with_events(r->mp, mq, mb)) == NULL) {
mb = NULL;
break;
}
e = rtmp_process_event(r, e, &mb);
} while(e == NULL);
if(mb != NULL)
media_buf_free_unlocked(r->mp, mb);
return e;
}
