static int config_get(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc;
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(lls_get_samplerate(sdi));
break;
case SR_CONF_CAPTURE_RATIO:
*data = g_variant_new_uint64(devc->capture_ratio);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
{
struct session_vdev *vdev;
switch (id) {
case SR_CONF_SAMPLERATE:
if (sdi) {
vdev = sdi->priv;
*data = g_variant_new_uint64(vdev->samplerate);
} else
return SR_ERR;
break;
case SR_CONF_LIMIT_SAMPLES:
if (sdi) {
vdev = sdi->priv;
*data = g_variant_new_uint64(vdev->total_samples);
} else
return SR_ERR;
break;
default:
return SR_ERR_ARG;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
int ret;
struct dev_context *devc;
(void)cg;
if (!sdi || !(devc = sdi->priv))
return SR_ERR_ARG;
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_POWER_OFF:
*data = g_variant_new_boolean(FALSE);
break;
default:
return SR_ERR_NA;
}
return ret;
}
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
{
struct dev_context *const devc = sdi->priv;
switch (id) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_DEVICE_MODE:
*data = g_variant_new_string(mode_strings[sdi->mode]);
break;
case SR_CONF_PATTERN_MODE:
*data = g_variant_new_string(pattern_strings[devc->sample_generator]);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *range[2];
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_CAPTURE_RATIO:
*data = g_variant_new_uint64(devc->capture_ratio);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
range[0] = g_variant_new_double(devc->cur_threshold);
range[1] = g_variant_new_double(devc->cur_threshold);
*data = g_variant_new_tuple(range, 2);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc = sdi->priv;
struct parport *port;
int idx, ch = -1;
if (cg) /* sr_config_get will validate cg using config_list */
ch = ((struct sr_channel *)cg->channels->data)->index;
switch (key) {
case SR_CONF_CONN:
port = sdi->conn;
*data = g_variant_new_string(port->name);
break;
case SR_CONF_LIMIT_FRAMES:
*data = g_variant_new_uint64(devc->frame_limit);
break;
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(samplerates[devc->rate]);
break;
case SR_CONF_TRIGGER_SOURCE:
if ((idx = std_u8_idx_s(devc->cctl[0] & 0xC0, ARRAY_AND_SIZE(trigger_sources_map))) < 0)
return SR_ERR_BUG;
*data = g_variant_new_string(trigger_sources[idx]);
break;
case SR_CONF_TRIGGER_SLOPE:
if (devc->edge >= ARRAY_SIZE(trigger_slopes))
return SR_ERR;
*data = g_variant_new_string(trigger_slopes[devc->edge]);
break;
case SR_CONF_BUFFERSIZE:
*data = g_variant_new_uint64(buffersizes[devc->last_step]);
break;
case SR_CONF_VDIV:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
if ((idx = std_u8_idx_s(devc->cctl[ch] & 0x33, ARRAY_AND_SIZE(vdivs_map))) < 0)
return SR_ERR_BUG;
*data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
break;
case SR_CONF_COUPLING:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
if ((idx = std_u8_idx_s(devc->cctl[ch] & 0x0C, ARRAY_AND_SIZE(coupling_map))) < 0)
return SR_ERR_BUG;
*data = g_variant_new_string(coupling[idx]);
break;
case SR_CONF_PROBE_FACTOR:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
*data = g_variant_new_uint64(devc->probe[ch]);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_channel *ch;
struct analog_gen *ag;
int pattern;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_AVERAGING:
*data = g_variant_new_boolean(devc->avg);
break;
case SR_CONF_AVG_SAMPLES:
*data = g_variant_new_uint64(devc->avg_samples);
break;
case SR_CONF_PATTERN_MODE:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
/* Any channel in the group will do. */
ch = cg->channels->data;
if (ch->type == SR_CHANNEL_LOGIC) {
pattern = devc->logic_pattern;
*data = g_variant_new_string(logic_pattern_str[pattern]);
} else if (ch->type == SR_CHANNEL_ANALOG) {
ag = g_hash_table_lookup(devc->ch_ag, ch);
pattern = ag->pattern;
*data = g_variant_new_string(analog_pattern_str[pattern]);
} else
return SR_ERR_BUG;
break;
case SR_CONF_AMPLITUDE:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
/* Any channel in the group will do. */
ch = cg->channels->data;
if (ch->type != SR_CHANNEL_ANALOG)
return SR_ERR_ARG;
ag = g_hash_table_lookup(devc->ch_ag, ch);
*data = g_variant_new_double(ag->amplitude);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_usb_dev_inst *usb;
GVariant *range[2];
char str[128];
int ret;
unsigned int i;
(void)cg;
ret = SR_OK;
switch (key) {
case SR_CONF_CONN:
if (!sdi || !sdi->conn)
return SR_ERR_ARG;
usb = sdi->conn;
if (usb->address == 255)
/* Device still needs to re-enumerate after firmware
* upload, so we don't know its (future) address. */
return SR_ERR;
snprintf(str, 128, "%d.%d", usb->bus, usb->address);
*data = g_variant_new_string(str);
break;
case SR_CONF_SAMPLERATE:
if (!sdi)
return SR_ERR;
devc = sdi->priv;
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_CAPTURE_RATIO:
if (!sdi)
return SR_ERR;
devc = sdi->priv;
*data = g_variant_new_uint64(devc->capture_ratio);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
if (!sdi)
return SR_ERR;
devc = sdi->priv;
ret = SR_ERR;
for (i = 0; i < ARRAY_SIZE(volt_thresholds); i++) {
if (devc->selected_voltage_range !=
volt_thresholds[i].range)
continue;
range[0] = g_variant_new_double(volt_thresholds[i].low);
range[1] = g_variant_new_double(volt_thresholds[i].high);
*data = g_variant_new_tuple(range, 2);
ret = SR_OK;
break;
}
break;
default:
return SR_ERR_NA;
}
return ret;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *tuple, *range[2];
GVariantBuilder gvb;
unsigned int i;
int ret;
(void)cg;
ret = SR_OK;
if (!sdi) {
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
break;
default:
return SR_ERR_NA;
}
} else {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SPL_WEIGHT_FREQ:
*data = g_variant_new_strv(weight_freq, ARRAY_SIZE(weight_freq));
break;
case SR_CONF_SPL_WEIGHT_TIME:
*data = g_variant_new_strv(weight_time, ARRAY_SIZE(weight_time));
break;
case SR_CONF_SPL_MEASUREMENT_RANGE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(meas_ranges); i++) {
range[0] = g_variant_new_uint64(meas_ranges[i][0]);
range[1] = g_variant_new_uint64(meas_ranges[i][1]);
tuple = g_variant_new_tuple(range, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_DATA_SOURCE:
*data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
break;
default:
return SR_ERR_NA;
}
}
return ret;
}
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{
GVariant *tuple, *rational[2];
GVariantBuilder gvb;
unsigned int i;
struct dev_context *devc;
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
break;
case SR_CONF_COUPLING:
*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
break;
case SR_CONF_VDIV:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
rational[0] = g_variant_new_uint64(vdivs[i][0]);
rational[1] = g_variant_new_uint64(vdivs[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TIMEBASE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(timebases); i++) {
rational[0] = g_variant_new_uint64(timebases[i][0]);
rational[1] = g_variant_new_uint64(timebases[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_SOURCE:
if (!sdi || !sdi->priv)
/* Can't know this until we have the exact model. */
return SR_ERR_ARG;
devc = sdi->priv;
*data = g_variant_new_strv(trigger_sources,
devc->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
size_t idx;
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->samplerate);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_EXTERNAL_CLOCK:
*data = g_variant_new_boolean(devc->cfg_clock_source
== CLOCK_EXT_CLK);
break;
case SR_CONF_CLOCK_EDGE:
idx = devc->cfg_clock_edge;
if (idx >= ARRAY_SIZE(signal_edge_names))
return SR_ERR_BUG;
*data = g_variant_new_string(signal_edge_names[idx]);
break;
case SR_CONF_TRIGGER_SOURCE:
idx = devc->cfg_trigger_source;
if (idx >= ARRAY_SIZE(trigger_source_names))
return SR_ERR_BUG;
*data = g_variant_new_string(trigger_source_names[idx]);
break;
case SR_CONF_TRIGGER_SLOPE:
idx = devc->cfg_trigger_slope;
if (idx >= ARRAY_SIZE(signal_edge_names))
return SR_ERR_BUG;
*data = g_variant_new_string(signal_edge_names[idx]);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc;
(void)cg;
if (!sdi || !data)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_VOLTAGE:
*data = g_variant_new_double(devc->voltage);
break;
case SR_CONF_VOLTAGE_TARGET:
*data = g_variant_new_double(devc->voltage_max);
break;
case SR_CONF_CURRENT:
*data = g_variant_new_double(devc->current);
break;
case SR_CONF_CURRENT_LIMIT:
*data = g_variant_new_double(devc->current_max);
break;
case SR_CONF_ENABLED:
*data = g_variant_new_boolean(devc->output_enabled);
break;
case SR_CONF_REGULATION:
/* Dual channel not supported. */
*data = g_variant_new_string((devc->cc_mode[0]) ? "CC" : "CV");
break;
case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
*data = g_variant_new_boolean(devc->ocp_enabled);
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
*data = g_variant_new_boolean(devc->ovp_enabled);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *gvar, *grange[2];
GVariantBuilder gvb;
struct dev_context *devc;
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
if (!sdi || !sdi->priv || !(devc = sdi->priv))
return SR_ERR_BUG;
cv_fill_samplerates_if_needed(sdi);
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
devc->samplerates,
ARRAY_SIZE(devc->samplerates),
sizeof(uint64_t));
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_LIMIT_SAMPLES:
if (!sdi || !sdi->priv || !(devc = sdi->priv) || !devc->prof)
return SR_ERR_BUG;
grange[0] = g_variant_new_uint64(0);
if (devc->prof->model == CHRONOVU_LA8)
grange[1] = g_variant_new_uint64(MAX_NUM_SAMPLES);
else
grange[1] = g_variant_new_uint64(MAX_NUM_SAMPLES / 2);
*data = g_variant_new_tuple(grange, 2);
break;
case SR_CONF_TRIGGER_MATCH:
if (!sdi || !sdi->priv || !(devc = sdi->priv) || !devc->prof)
return SR_ERR_BUG;
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
trigger_matches, devc->prof->num_trigger_matches,
sizeof(int32_t));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *rational[2];
const uint64_t *si;
(void)cg;
devc = sdi->priv;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_SAMPLE_INTERVAL:
si = kecheng_kc_330b_sample_intervals[devc->sample_interval];
rational[0] = g_variant_new_uint64(si[0]);
rational[1] = g_variant_new_uint64(si[1]);
*data = g_variant_new_tuple(rational, 2);
break;
case SR_CONF_DATALOG:
/* There really isn't a way to be sure the device is logging. */
return SR_ERR_NA;
break;
case SR_CONF_SPL_WEIGHT_FREQ:
if (devc->mqflags & SR_MQFLAG_SPL_FREQ_WEIGHT_A)
*data = g_variant_new_string("A");
else
*data = g_variant_new_string("C");
break;
case SR_CONF_SPL_WEIGHT_TIME:
if (devc->mqflags & SR_MQFLAG_SPL_TIME_WEIGHT_F)
*data = g_variant_new_string("F");
else
*data = g_variant_new_string("S");
break;
case SR_CONF_DATA_SOURCE:
if (devc->data_source == DATA_SOURCE_LIVE)
*data = g_variant_new_string("Live");
else
*data = g_variant_new_string("Memory");
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_channel *ch;
struct analog_gen *ag;
int pattern;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (id) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_PATTERN_MODE:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
ch = cg->channels->data;
if (ch->type == SR_CHANNEL_LOGIC) {
pattern = devc->logic_pattern;
*data = g_variant_new_string(logic_pattern_str[pattern]);
} else if (ch->type == SR_CHANNEL_ANALOG) {
ag = cg->priv;
pattern = ag->pattern;
*data = g_variant_new_string(analog_pattern_str[pattern]);
} else
return SR_ERR_BUG;
break;
case SR_CONF_NUM_LOGIC_CHANNELS:
*data = g_variant_new_int32(devc->num_logic_channels);
break;
case SR_CONF_NUM_ANALOG_CHANNELS:
*data = g_variant_new_int32(devc->num_analog_channels);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static GVariant *get_rtc_time(void) {
struct rtc_time rtc;
struct tm tm;
time_t rtc_time = 0;
int fd, r;
fd = open(RTC_DEVICE, O_RDONLY);
if (fd < 0)
goto error;
r = ioctl(fd, RTC_RD_TIME, &rtc);
close(fd);
if (r)
goto error;
tm.tm_sec = rtc.tm_sec;
tm.tm_min = rtc.tm_min;
tm.tm_hour = rtc.tm_hour;
tm.tm_mday = rtc.tm_mday;
tm.tm_mon = rtc.tm_mon;
tm.tm_year = rtc.tm_year;
tm.tm_isdst = 0;
/* This is the raw time as if the RTC was in UTC */
rtc_time = timegm(&tm);
error:
return g_variant_new_uint64((guint64)rtc_time * 1000000);
}
void DeviceOptions::samplerate_double_setter(
struct sr_dev_inst *sdi, GVariant *value)
{
GVariant *const gvar = g_variant_new_uint64(
g_variant_get_double(value));
config_setter(sdi, SR_CONF_SAMPLERATE, gvar);
}
static void
ide_preferences_spin_button_value_changed (IdePreferencesSpinButton *self,
GParamSpec *pspec,
GtkSpinButton *spin_button)
{
GVariant *variant = NULL;
gdouble value;
g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self));
g_assert (pspec != NULL);
g_assert (GTK_IS_SPIN_BUTTON (spin_button));
value = gtk_spin_button_get_value (spin_button);
if (g_variant_type_equal (self->type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT16))
variant = g_variant_new_int16 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT16))
variant = g_variant_new_uint16 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT32))
variant = g_variant_new_int32 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT32))
variant = g_variant_new_uint32 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT64))
variant = g_variant_new_int64 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT64))
variant = g_variant_new_uint64 (value);
else
g_return_if_reached ();
g_variant_ref_sink (variant);
g_settings_set_value (self->settings, self->key, variant);
g_clear_pointer (&variant, g_variant_unref);
}
static void runTest(WebViewTest* test, const char* name)
{
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&builder, "{sv}", "pageID", g_variant_new_uint64(webkit_web_view_get_page_id(test->m_webView)));
g_assert(testRunner->runTest("WebKitDOMXPathNSResolver", name, g_variant_builder_end(&builder)));
}
static gboolean
ipcam_event_input_msg_handler_update_param(IpcamEventInputMsgHandler *handler, const gchar *name, JsonObject *value_obj)
{
IpcamIConfig *iconfig;
g_object_get(G_OBJECT(handler), "app", &iconfig, NULL);
GList *members, *item;
Schedules *sche = g_new(Schedules, 1);
GVariant *value = NULL;
gboolean ret = FALSE;
members = json_object_get_members(value_obj);
for (item = g_list_first(members); item; item = g_list_next(item))
{
const gchar *sub_name = item->data;
if (g_str_equal(sub_name, "enable"))
{
value = g_variant_new_boolean(json_object_get_boolean_member(value_obj, sub_name));
}
else if (g_str_equal(sub_name, "schedules"))
{
gint i = 0;
JsonObject *sub_obj = json_object_get_object_member(value_obj, sub_name);
for (i = ENUM_MON; i < ENUM_WEEKDAY_LAST; i++)
{
if (json_object_has_member(sub_obj, weekday_name[i]))
{
sche->schedule[i] = (gchar *)json_object_get_string_member(sub_obj, weekday_name[i]);
}
else
{
sche->schedule[i] = g_malloc0(1);
}
}
if (IS_64BIT_MACHINE)
{
value = g_variant_new_uint64(GPOINTER_TO_SIZE(sche));
}
else
{
value = g_variant_new_uint32(GPOINTER_TO_SIZE(sche));
}
}
else
{
g_warn_if_reached();
}
if (value)
{
ret = ipcam_iconfig_update(iconfig, IPCAM_EVENT_INPUT_TYPE, name, sub_name, value);
g_variant_unref(value);
value = NULL;
}
}
g_free(sche);
g_list_free(members);
return ret;
}
static int config_get(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc;
uint64_t low, high;
uint64_t tmp;
int ret;
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_SPL_WEIGHT_FREQ:
tmp = pce_322a_weight_freq_get(sdi);
if (tmp == SR_MQFLAG_SPL_FREQ_WEIGHT_A)
*data = g_variant_new_string("A");
else if (tmp == SR_MQFLAG_SPL_FREQ_WEIGHT_C)
*data = g_variant_new_string("C");
else
return SR_ERR;
break;
case SR_CONF_SPL_WEIGHT_TIME:
tmp = pce_322a_weight_time_get(sdi);
if (tmp == SR_MQFLAG_SPL_TIME_WEIGHT_F)
*data = g_variant_new_string("F");
else if (tmp == SR_MQFLAG_SPL_TIME_WEIGHT_S)
*data = g_variant_new_string("S");
else
return SR_ERR;
break;
case SR_CONF_SPL_MEASUREMENT_RANGE:
if ((ret = pce_322a_meas_range_get(sdi, &low, &high)) == SR_OK)
*data = std_gvar_tuple_u64(low, high);
else
return ret;
break;
case SR_CONF_POWER_OFF:
*data = g_variant_new_boolean(FALSE);
break;
case SR_CONF_DATA_SOURCE:
if (devc->cur_data_source == DATA_SOURCE_LIVE)
*data = g_variant_new_string("Live");
else
*data = g_variant_new_string("Memory");
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static GVariant *
uint_enum_set_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
UIntEnumBinding *binding = user_data;
return g_variant_new_uint64 (binding->values[g_value_get_int (value)]);
}
static GVariant *build_tuples(const uint64_t (*array)[][2], unsigned int n)
{
unsigned int i;
GVariant *rational[2];
GVariantBuilder gvb;
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < n; i++) {
rational[0] = g_variant_new_uint64((*array)[i][0]);
rational[1] = g_variant_new_uint64((*array)[i][1]);
/* FIXME: Valgrind reports a memory leak here. */
g_variant_builder_add_value(&gvb, g_variant_new_tuple(rational, 2));
}
return g_variant_builder_end(&gvb);
}
static struct sr_option *get_options(void)
{
if (!options[0].def) {
options[0].def = g_variant_ref_sink(g_variant_new_int32(DEFAULT_NUM_CHANNELS));
options[1].def = g_variant_ref_sink(g_variant_new_uint64(DEFAULT_SAMPLERATE));
}
return options;
}
static int process_buffer(struct sr_input *in)
{
struct context *inc;
struct sr_datafeed_meta meta;
struct sr_datafeed_packet packet;
struct sr_config *src;
unsigned int offset, chunk_size;
inc = in->priv;
if (!inc->started) {
std_session_send_df_header(in->sdi, LOG_PREFIX);
if (inc->samplerate) {
packet.type = SR_DF_META;
packet.payload = &meta;
src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(inc->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
g_slist_free(meta.config);
sr_config_free(src);
}
inc->started = TRUE;
}
/* Round down to the last channels * unitsize boundary. */
inc->analog.num_samples = CHUNK_SIZE / inc->samplesize;
chunk_size = inc->analog.num_samples * inc->samplesize;
offset = 0;
while ((offset + chunk_size) < in->buf->len) {
inc->analog.data = in->buf->str + offset;
sr_session_send(in->sdi, &inc->packet);
offset += chunk_size;
}
inc->analog.num_samples = (in->buf->len - offset) / inc->samplesize;
chunk_size = inc->analog.num_samples * inc->samplesize;
if (chunk_size > 0) {
inc->analog.data = in->buf->str + offset;
sr_session_send(in->sdi, &inc->packet);
offset += chunk_size;
}
if ((unsigned int)offset < in->buf->len) {
/*
* The incoming buffer wasn't processed completely. Stash
* the leftover data for next time.
*/
g_string_erase(in->buf, 0, offset);
} else {
g_string_truncate(in->buf, 0);
}
return SR_OK;
}
/**
* rb_query_creator_get_limit:
* @creator: #RBQueryCreator instance
* @type: (out): used to return the limit type
* @limit: (out): used to return the limit value
*
* Retrieves the limit type and value from the query creator.
*/
void
rb_query_creator_get_limit (RBQueryCreator *creator,
RhythmDBQueryModelLimitType *type,
GVariant **limit)
{
RBQueryCreatorPrivate *priv;
g_return_if_fail (RB_IS_QUERY_CREATOR (creator));
priv = QUERY_CREATOR_GET_PRIVATE (creator);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->limit_check))) {
guint64 l;
l = gtk_spin_button_get_value(GTK_SPIN_BUTTON (priv->limit_entry));
switch (gtk_combo_box_get_active (GTK_COMBO_BOX (priv->limit_option))) {
case 0:
*type = RHYTHMDB_QUERY_MODEL_LIMIT_COUNT;
*limit = g_variant_new_uint64 (l);
break;
case 1:
*type = RHYTHMDB_QUERY_MODEL_LIMIT_SIZE;
*limit = g_variant_new_uint64 (l);
break;
case 2:
*type = RHYTHMDB_QUERY_MODEL_LIMIT_SIZE;
*limit = g_variant_new_uint64 (l * 1000);
break;
case 3:
*type = RHYTHMDB_QUERY_MODEL_LIMIT_TIME;
*limit = g_variant_new_uint64 (l * 60);
break;
default:
g_assert_not_reached ();
}
} else {
*type = RHYTHMDB_QUERY_MODEL_LIMIT_NONE;
*limit = NULL;
}
}
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_probe_group *probe_group)
{
struct dev_context *const devc = sdi->priv;
(void)probe_group;
switch (id) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_PATTERN_MODE:
switch (devc->sample_generator) {
case PATTERN_SIGROK:
*data = g_variant_new_string(STR_PATTERN_SIGROK);
break;
case PATTERN_RANDOM:
*data = g_variant_new_string(STR_PATTERN_RANDOM);
break;
case PATTERN_INC:
*data = g_variant_new_string(STR_PATTERN_INC);
break;
case PATTERN_ALL_LOW:
*data = g_variant_new_string(STR_PATTERN_ALL_LOW);
break;
case PATTERN_ALL_HIGH:
*data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
break;
}
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static GVariant *
g_settings_set_mapping_float (const GValue *value,
const GVariantType *expected_type)
{
GVariant *variant = NULL;
gdouble d;
gint64 l;
if (G_VALUE_HOLDS_DOUBLE (value))
d = g_value_get_double (value);
else
return NULL;
l = (gint64) d;
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
{
if (G_MININT16 <= l && l <= G_MAXINT16)
variant = g_variant_new_int16 ((gint16) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
{
if (0 <= l && l <= G_MAXUINT16)
variant = g_variant_new_uint16 ((guint16) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (G_MININT32 <= l && l <= G_MAXINT32)
variant = g_variant_new_int32 ((gint) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
if (0 <= l && l <= G_MAXUINT32)
variant = g_variant_new_uint32 ((guint) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
{
if (G_MININT64 <= l && l <= G_MAXINT64)
variant = g_variant_new_int64 ((gint64) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
{
if (0 <= l && l <= G_MAXUINT64)
variant = g_variant_new_uint64 ((guint64) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
{
if (0 <= l && l <= G_MAXUINT32)
variant = g_variant_new_handle ((guint) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double ((gdouble) d);
return variant;
}
static int process_buffer(struct sr_input *in)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
struct sr_datafeed_logic logic;
struct sr_config *src;
struct context *inc;
gsize chunk_size, i;
gsize chunk;
uint16_t unitsize;
inc = in->priv;
unitsize = (g_slist_length(in->sdi->channels) + 7) / 8;
if (!inc->started) {
std_session_send_df_header(in->sdi);
if (inc->samplerate) {
packet.type = SR_DF_META;
packet.payload = &meta;
src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(inc->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
g_slist_free(meta.config);
sr_config_free(src);
}
inc->samples_remain = CHRONOVU_LA8_DATASIZE;
inc->samples_remain /= unitsize;
inc->started = TRUE;
}
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.unitsize = unitsize;
/* Cut off at multiple of unitsize. Avoid sending the "header". */
chunk_size = in->buf->len / logic.unitsize * logic.unitsize;
chunk_size = MIN(chunk_size, inc->samples_remain * unitsize);
for (i = 0; i < chunk_size; i += chunk) {
logic.data = in->buf->str + i;
chunk = MIN(CHUNK_SIZE, chunk_size - i);
if (chunk) {
logic.length = chunk;
sr_session_send(in->sdi, &packet);
inc->samples_remain -= chunk / unitsize;
}
}
g_string_erase(in->buf, 0, chunk_size);
return SR_OK;
}
void DecoderStack::decode_proc()
{
optional<int64_t> sample_count;
srd_session *session;
srd_decoder_inst *prev_di = NULL;
assert(_snapshot);
// Create the session
srd_session_new(&session);
assert(session);
// Create the decoders
const unsigned int unit_size = _snapshot->unit_size();
for (const shared_ptr<decode::Decoder> &dec : _stack)
{
srd_decoder_inst *const di = dec->create_decoder_inst(session, unit_size);
if (!di)
{
_error_message = tr("Failed to create decoder instance");
srd_session_destroy(session);
return;
}
if (prev_di)
srd_inst_stack (session, prev_di, di);
prev_di = di;
}
// Get the intial sample count
{
unique_lock<mutex> input_lock(_input_mutex);
sample_count = _sample_count = _snapshot->get_sample_count();
}
// Start the session
srd_session_metadata_set(session, SRD_CONF_SAMPLERATE,
g_variant_new_uint64((uint64_t)_samplerate));
srd_pd_output_callback_add(session, SRD_OUTPUT_ANN,
DecoderStack::annotation_callback, this);
srd_session_start(session);
do {
decode_data(*sample_count, unit_size, session);
} while(_error_message.isEmpty() && (sample_count = wait_for_data()));
// Destroy the session
srd_session_destroy(session);
}
