/* Callback handling data */ static int receive_data(int fd, int revents, const struct sr_dev_inst *sdi) { struct dev_context *devc = sdi->priv; struct sr_datafeed_packet packet; struct sr_datafeed_logic logic; struct sr_datafeed_dso dso; struct sr_datafeed_analog analog; static uint64_t samples_to_send, expected_samplenum, sending_now; int64_t time, elapsed; static uint16_t last_sample = 0; uint16_t cur_sample; int i; (void)fd; (void)revents; /* How many "virtual" samples should we have collected by now? */ time = g_get_monotonic_time(); elapsed = time - devc->starttime; devc->starttime = time; //expected_samplenum = ceil(elapsed / 1000000.0 * devc->cur_samplerate); /* Of those, how many do we still have to send? */ //samples_to_send = (expected_samplenum - devc->samples_counter) / CONST_LEN * CONST_LEN; //samples_to_send = expected_samplenum / CONST_LEN * CONST_LEN; samples_to_send = ceil(elapsed / 1000000.0 * devc->cur_samplerate); if (devc->limit_samples) { if ((sdi->mode == DSO && !devc->instant) || sdi->mode == ANALOG) samples_to_send = MIN(samples_to_send, devc->limit_samples - devc->pre_index); else samples_to_send = MIN(samples_to_send, devc->limit_samples - devc->samples_counter); } while (samples_to_send > 0) { sending_now = MIN(samples_to_send, BUFSIZE); samples_generator(devc->buf, sending_now, sdi, devc); if (devc->trigger_stage != 0) { for (i = 0; i < sending_now; i++) { if (devc->trigger_edge == 0) { if ((*(devc->buf + i) | devc->trigger_mask) == (devc->trigger_value | devc->trigger_mask)) { devc->trigger_stage = 0; break; } } else { cur_sample = *(devc->buf + i); if (((last_sample & devc->trigger_edge) == (~devc->trigger_value & devc->trigger_edge)) && ((cur_sample | devc->trigger_mask) == (devc->trigger_value | devc->trigger_mask)) && ((cur_sample & devc->trigger_edge) == (devc->trigger_value & devc->trigger_edge))) { devc->trigger_stage = 0; break; } last_sample = cur_sample; } } if (devc->trigger_stage == 0) { struct ds_trigger_pos demo_trigger_pos; demo_trigger_pos.real_pos = i; packet.type = SR_DF_TRIGGER; packet.payload = &demo_trigger_pos; sr_session_send(sdi, &packet); } } if (sdi->mode == ANALOG) devc->samples_counter += sending_now/g_slist_length(sdi->channels); else devc->samples_counter += sending_now; if (sdi->mode == DSO && !devc->instant && devc->samples_counter > devc->limit_samples) devc->samples_counter = devc->limit_samples; if (devc->trigger_stage == 0){ samples_to_send -= sending_now; if (sdi->mode == LOGIC) { packet.type = SR_DF_LOGIC; packet.payload = &logic; logic.length = sending_now * (NUM_PROBES >> 3); logic.unitsize = (NUM_PROBES >> 3); logic.data = devc->buf; } else if (sdi->mode == DSO) {
static int auto_scroll_timeout_callback (gpointer data) { NemoIconContainer *container; GtkWidget *widget; float x_scroll_delta, y_scroll_delta; GdkRectangle exposed_area; GtkAllocation allocation; g_assert (NEMO_IS_ICON_CONTAINER (data)); widget = GTK_WIDGET (data); container = NEMO_ICON_CONTAINER (widget); if (container->details->dnd_info->drag_info.waiting_to_autoscroll && container->details->dnd_info->drag_info.start_auto_scroll_in > g_get_monotonic_time ()) { /* not yet */ return TRUE; } container->details->dnd_info->drag_info.waiting_to_autoscroll = FALSE; nemo_drag_autoscroll_calculate_delta (widget, &x_scroll_delta, &y_scroll_delta); if (x_scroll_delta == 0 && y_scroll_delta == 0) { /* no work */ return TRUE; } /* Clear the old dnd highlight frame */ dnd_highlight_queue_redraw (widget); if (!nemo_icon_container_scroll (container, (int)x_scroll_delta, (int)y_scroll_delta)) { /* the scroll value got pinned to a min or max adjustment value, * we ended up not scrolling */ return TRUE; } /* Make sure the dnd highlight frame is redrawn */ dnd_highlight_queue_redraw (widget); /* update cached drag start offsets */ container->details->dnd_info->drag_info.start_x -= x_scroll_delta; container->details->dnd_info->drag_info.start_y -= y_scroll_delta; /* Due to a glitch in GtkLayout, whe need to do an explicit draw of the exposed * area. * Calculate the size of the area we need to draw */ gtk_widget_get_allocation (widget, &allocation); exposed_area.x = allocation.x; exposed_area.y = allocation.y; exposed_area.width = allocation.width; exposed_area.height = allocation.height; if (x_scroll_delta > 0) { exposed_area.x = exposed_area.width - x_scroll_delta; } else if (x_scroll_delta < 0) { exposed_area.width = -x_scroll_delta; } if (y_scroll_delta > 0) { exposed_area.y = exposed_area.height - y_scroll_delta; } else if (y_scroll_delta < 0) { exposed_area.height = -y_scroll_delta; } /* offset it to 0, 0 */ exposed_area.x -= allocation.x; exposed_area.y -= allocation.y; gtk_widget_queue_draw_area (widget, exposed_area.x, exposed_area.y, exposed_area.width, exposed_area.height); return TRUE; }
int main (int argc, char *argv[]) { int t_secs = 30; gboolean exit_no_nm = FALSE; gboolean wait_startup = FALSE; Timeout timeout; GOptionContext *opt_ctx = NULL; gboolean success; NMClient *client; NMState state = NM_STATE_UNKNOWN; GMainLoop *loop; gint64 remaining_ms; GError *error = NULL; GOptionEntry options[] = { {"timeout", 't', 0, G_OPTION_ARG_INT, &t_secs, N_("Time to wait for a connection, in seconds (without the option, default value is 30)"), "<timeout>"}, {"exit", 'x', 0, G_OPTION_ARG_NONE, &exit_no_nm, N_("Exit immediately if NetworkManager is not running or connecting"), NULL}, {"quiet", 'q', 0, G_OPTION_ARG_NONE, &timeout.quiet, N_("Don't print anything"), NULL}, {"wait-for-startup", 's', 0, G_OPTION_ARG_NONE, &wait_startup, N_("Wait for NetworkManager startup instead of a connection"), NULL}, {NULL} }; timeout.start_timestamp_ms = g_get_monotonic_time () / (G_USEC_PER_SEC / 1000); timeout.quiet = FALSE; /* Set locale to be able to use environment variables */ setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, NMLOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); opt_ctx = g_option_context_new (NULL); g_option_context_set_translation_domain (opt_ctx, GETTEXT_PACKAGE); g_option_context_set_ignore_unknown_options (opt_ctx, FALSE); g_option_context_set_help_enabled (opt_ctx, TRUE); g_option_context_add_main_entries (opt_ctx, options, NULL); g_option_context_set_summary (opt_ctx, _("Waits for NetworkManager to finish activating startup network connections.")); success = g_option_context_parse (opt_ctx, &argc, &argv, NULL); g_option_context_free (opt_ctx); if (!success) { g_printerr ("%s: %s\n", argv[0], _("Invalid option. Please use --help to see a list of valid options.")); return 2; } if (t_secs < 0 || t_secs > 3600) { g_printerr ("%s: %s\n", argv[0], _("Invalid option. Please use --help to see a list of valid options.")); return 2; } remaining_ms = t_secs * 1000; nm_g_type_init (); client = nm_client_new (NULL, &error); if (!client) { g_printerr (_("Error: Could not create NMClient object: %s."), error->message); g_error_free (error); return 2; } loop = g_main_loop_new (NULL, FALSE); g_object_set_data (G_OBJECT (client), WAIT_STARTUP_TAG, GUINT_TO_POINTER (wait_startup)); state = nm_client_get_state (client); if (!nm_client_get_nm_running (client)) { if (exit_no_nm) { g_object_unref (client); return 1; } } else if (wait_startup) { if (!nm_client_get_startup (client)) { g_object_unref (client); return 0; } } else { if ( state == NM_STATE_CONNECTED_LOCAL || state == NM_STATE_CONNECTED_SITE || state == NM_STATE_CONNECTED_GLOBAL) { g_object_unref (client); return 0; } } if (exit_no_nm && (state != NM_STATE_CONNECTING)) { g_object_unref (client); return 1; } if (remaining_ms == 0) { g_object_unref (client); return 1; } g_signal_connect (client, "notify", G_CALLBACK (client_properties_changed), loop); timeout.end_timestamp_ms = timeout.start_timestamp_ms + remaining_ms; timeout.progress_step_duration = (timeout.end_timestamp_ms - timeout.start_timestamp_ms + PROGRESS_STEPS/2) / PROGRESS_STEPS; g_timeout_add (timeout.quiet ? remaining_ms : 0, handle_timeout, &timeout); g_main_loop_run (loop); g_main_loop_unref (loop); g_object_unref (client); return 0; }
static GSList *scan(struct sr_dev_driver *di, GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_usb_dev_inst *usb; struct sr_config *src; const struct hantek_6xxx_profile *prof; GSList *l, *devices, *conn_devices; struct libusb_device_descriptor des; libusb_device **devlist; int i, j; const char *conn; char connection_id[64]; drvc = di->context; devices = 0; conn = NULL; for (l = options; l; l = l->next) { src = l->data; if (src->key == SR_CONF_CONN) { conn = g_variant_get_string(src->data, NULL); break; } } if (conn) conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn); else conn_devices = NULL; /* Find all Hantek 60xx devices and upload firmware to all of them. */ libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); for (i = 0; devlist[i]; i++) { if (conn) { usb = NULL; for (l = conn_devices; l; l = l->next) { usb = l->data; if (usb->bus == libusb_get_bus_number(devlist[i]) && usb->address == libusb_get_device_address(devlist[i])) break; } if (!l) /* This device matched none of the ones that * matched the conn specification. */ continue; } libusb_get_device_descriptor(devlist[i], &des); usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)); prof = NULL; for (j = 0; dev_profiles[j].orig_vid; j++) { if (des.idVendor == dev_profiles[j].orig_vid && des.idProduct == dev_profiles[j].orig_pid) { /* Device matches the pre-firmware profile. */ prof = &dev_profiles[j]; sr_dbg("Found a %s %s.", prof->vendor, prof->model); sdi = hantek_6xxx_dev_new(prof); sdi->connection_id = g_strdup(connection_id); devices = g_slist_append(devices, sdi); devc = sdi->priv; if (ezusb_upload_firmware(drvc->sr_ctx, devlist[i], USB_CONFIGURATION, prof->firmware) == SR_OK) /* Remember when the firmware on this device was updated. */ devc->fw_updated = g_get_monotonic_time(); else sr_err("Firmware upload failed."); /* Dummy USB address of 0xff will get overwritten later. */ sdi->conn = sr_usb_dev_inst_new( libusb_get_bus_number(devlist[i]), 0xff, NULL); break; } else if (des.idVendor == dev_profiles[j].fw_vid && des.idProduct == dev_profiles[j].fw_pid && des.bcdDevice == dev_profiles[j].fw_prod_ver) { /* Device matches the post-firmware profile. */ prof = &dev_profiles[j]; sr_dbg("Found a %s %s.", prof->vendor, prof->model); sdi = hantek_6xxx_dev_new(prof); sdi->connection_id = g_strdup(connection_id); sdi->status = SR_ST_INACTIVE; devices = g_slist_append(devices, sdi); sdi->inst_type = SR_INST_USB; sdi->conn = sr_usb_dev_inst_new( libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), NULL); break; } } if (!prof) /* Not a supported VID/PID. */ continue; } libusb_free_device_list(devlist, 1); return std_scan_complete(di, devices); }
/** * Try to find a valid packet in a serial data stream. * * @param serial Previously initialized serial port structure. * @param buf Buffer containing the bytes to write. * @param count Size of the buffer. * @param packet_size Size, in bytes, of a valid packet. * @param is_valid Callback that assesses whether the packet is valid or not. * @param timeout_ms The timeout after which, if no packet is detected, to * abort scanning. * @param baudrate The baudrate of the serial port. This parameter is not * critical, but it helps fine tune the serial port polling * delay. * * @return SR_OK if a valid packet is found within the given timeout, * SR_ERR upon failure. */ SR_PRIV int serial_stream_detect(struct sr_serial_dev_inst *serial, uint8_t *buf, size_t *buflen, size_t packet_size, packet_valid_t is_valid, uint64_t timeout_ms, int baudrate) { uint64_t start, time, byte_delay_us; size_t ibuf, i, maxlen; int len; maxlen = *buflen; sr_dbg("Detecting packets on FD %d (timeout = %" PRIu64 "ms, baudrate = %d).", serial->fd, timeout_ms, baudrate); if (maxlen < (packet_size / 2) ) { sr_err("Buffer size must be at least twice the packet size."); return SR_ERR; } /* Assume 8n1 transmission. That is 10 bits for every byte. */ byte_delay_us = 10 * (1000000 / baudrate); start = g_get_monotonic_time(); i = ibuf = len = 0; while (ibuf < maxlen) { len = serial_read(serial, &buf[ibuf], 1); if (len > 0) { ibuf += len; } else if (len == 0) { /* No logging, already done in serial_read(). */ } else { /* Error reading byte, but continuing anyway. */ } time = g_get_monotonic_time() - start; time /= 1000; if ((ibuf - i) >= packet_size) { /* We have at least a packet's worth of data. */ if (is_valid(&buf[i])) { sr_spew("Found valid %d-byte packet after " "%" PRIu64 "ms.", (ibuf - i), time); *buflen = ibuf; return SR_OK; } else { sr_spew("Got %d bytes, but not a valid " "packet.", (ibuf - i)); } /* Not a valid packet. Continue searching. */ i++; } if (time >= timeout_ms) { /* Timeout */ sr_dbg("Detection timed out after %dms.", time); break; } if (len < 1) g_usleep(byte_delay_us); } *buflen = ibuf; sr_err("Didn't find a valid packet (read %d bytes).", *buflen); return SR_ERR; }
static GSList *scan(struct sr_dev_driver *di, GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_usb_dev_inst *usb; struct sr_channel *ch; struct sr_channel_group *cg; struct sr_config *src; const struct fx2lafw_profile *prof; GSList *l, *devices, *conn_devices; gboolean has_firmware; struct libusb_device_descriptor des; libusb_device **devlist; struct libusb_device_handle *hdl; int ret, i, j; int num_logic_channels = 0, num_analog_channels = 0; const char *conn; char manufacturer[64], product[64], serial_num[64], connection_id[64]; char channel_name[16]; drvc = di->context; conn = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; } } if (conn) conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn); else conn_devices = NULL; /* Find all fx2lafw compatible devices and upload firmware to them. */ devices = NULL; libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); for (i = 0; devlist[i]; i++) { if (conn) { usb = NULL; for (l = conn_devices; l; l = l->next) { usb = l->data; if (usb->bus == libusb_get_bus_number(devlist[i]) && usb->address == libusb_get_device_address(devlist[i])) break; } if (!l) /* This device matched none of the ones that * matched the conn specification. */ continue; } libusb_get_device_descriptor( devlist[i], &des); if (!is_plausible(&des)) continue; if ((ret = libusb_open(devlist[i], &hdl)) < 0) { sr_warn("Failed to open potential device with " "VID:PID %04x:%04x: %s.", des.idVendor, des.idProduct, libusb_error_name(ret)); continue; } if (des.iManufacturer == 0) { manufacturer[0] = '\0'; } else if ((ret = libusb_get_string_descriptor_ascii(hdl, des.iManufacturer, (unsigned char *) manufacturer, sizeof(manufacturer))) < 0) { sr_warn("Failed to get manufacturer string descriptor: %s.", libusb_error_name(ret)); continue; } if (des.iProduct == 0) { product[0] = '\0'; } else if ((ret = libusb_get_string_descriptor_ascii(hdl, des.iProduct, (unsigned char *) product, sizeof(product))) < 0) { sr_warn("Failed to get product string descriptor: %s.", libusb_error_name(ret)); continue; } if (des.iSerialNumber == 0) { serial_num[0] = '\0'; } else if ((ret = libusb_get_string_descriptor_ascii(hdl, des.iSerialNumber, (unsigned char *) serial_num, sizeof(serial_num))) < 0) { sr_warn("Failed to get serial number string descriptor: %s.", libusb_error_name(ret)); continue; } libusb_close(hdl); if (usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)) < 0) continue; prof = NULL; for (j = 0; supported_fx2[j].vid; j++) { if (des.idVendor == supported_fx2[j].vid && des.idProduct == supported_fx2[j].pid && (!supported_fx2[j].usb_manufacturer || !strcmp(manufacturer, supported_fx2[j].usb_manufacturer)) && (!supported_fx2[j].usb_product || !strcmp(product, supported_fx2[j].usb_product))) { prof = &supported_fx2[j]; break; } } if (!prof) continue; sdi = g_malloc0(sizeof(struct sr_dev_inst)); sdi->status = SR_ST_INITIALIZING; sdi->vendor = g_strdup(prof->vendor); sdi->model = g_strdup(prof->model); sdi->version = g_strdup(prof->model_version); sdi->serial_num = g_strdup(serial_num); sdi->connection_id = g_strdup(connection_id); /* Fill in channellist according to this device's profile. */ num_logic_channels = prof->dev_caps & DEV_CAPS_16BIT ? 16 : 8; num_analog_channels = prof->dev_caps & DEV_CAPS_AX_ANALOG ? 1 : 0; /* Logic channels, all in one channel group. */ cg = g_malloc0(sizeof(struct sr_channel_group)); cg->name = g_strdup("Logic"); for (j = 0; j < num_logic_channels; j++) { sprintf(channel_name, "D%d", j); ch = sr_channel_new(sdi, j, SR_CHANNEL_LOGIC, TRUE, channel_name); cg->channels = g_slist_append(cg->channels, ch); } sdi->channel_groups = g_slist_append(NULL, cg); for (j = 0; j < num_analog_channels; j++) { snprintf(channel_name, 16, "A%d", j); ch = sr_channel_new(sdi, j + num_logic_channels, SR_CHANNEL_ANALOG, TRUE, channel_name); /* Every analog channel gets its own channel group. */ cg = g_malloc0(sizeof(struct sr_channel_group)); cg->name = g_strdup(channel_name); cg->channels = g_slist_append(NULL, ch); sdi->channel_groups = g_slist_append(sdi->channel_groups, cg); } devc = fx2lafw_dev_new(); devc->profile = prof; sdi->priv = devc; devices = g_slist_append(devices, sdi); devc->samplerates = samplerates; devc->num_samplerates = ARRAY_SIZE(samplerates); has_firmware = usb_match_manuf_prod(devlist[i], "sigrok", "fx2lafw"); if (has_firmware) { /* Already has the firmware, so fix the new address. */ sr_dbg("Found an fx2lafw device."); sdi->status = SR_ST_INACTIVE; sdi->inst_type = SR_INST_USB; sdi->conn = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), NULL); } else { if (ezusb_upload_firmware(drvc->sr_ctx, devlist[i], USB_CONFIGURATION, prof->firmware) == SR_OK) { /* Store when this device's FW was updated. */ devc->fw_updated = g_get_monotonic_time(); } else { sr_err("Firmware upload failed for " "device %d.%d (logical), name %s.", libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), prof->firmware); } sdi->inst_type = SR_INST_USB; sdi->conn = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]), 0xff, NULL); } } libusb_free_device_list(devlist, 1); g_slist_free_full(conn_devices, (GDestroyNotify)sr_usb_dev_inst_free); return std_scan_complete(di, devices); }
/** * Scan for Metrahit 2x in a bidirectional mode using Gossen Metrawatt * 'BD 232' interface. */ static GSList *scan_2x_bd232(struct sr_dev_driver *di, GSList *options) { struct sr_dev_inst *sdi; struct dev_context *devc; struct sr_config *src; struct sr_serial_dev_inst *serial; GSList *l, *devices; const char *conn, *serialcomm; int cnt, byte; gint64 timeout_us; sdi = NULL; devc = NULL; conn = serialcomm = NULL; devices = NULL; sr_spew("scan_2x_bd232() called!"); for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = SERIALCOMM_2X; serial = sr_serial_dev_inst_new(conn, serialcomm); if (serial_open(serial, SERIAL_RDWR) != SR_OK) goto exit_err; devc = g_malloc0(sizeof(struct dev_context)); sdi = g_malloc0(sizeof(struct sr_dev_inst)); sdi->status = SR_ST_INACTIVE; sdi->vendor = g_strdup(VENDOR_GMC); sdi->priv = devc; /* Send message 03 "Query multimeter version and status" */ sdi->conn = serial; if (req_stat14(sdi, TRUE) != SR_OK) goto exit_err; /* Wait for reply from device(s) for up to 2s. */ timeout_us = g_get_monotonic_time() + (2 * 1000 * 1000); while (timeout_us > g_get_monotonic_time()) { /* Receive reply (14 bytes) */ devc->buflen = 0; for (cnt = 0; cnt < GMC_REPLY_SIZE; cnt++) { byte = read_byte(serial, timeout_us); if (byte != -1) devc->buf[devc->buflen++] = (byte & MASK_6BITS); } if (devc->buflen != GMC_REPLY_SIZE) continue; devc->addr = devc->buf[0]; process_msg14(sdi); devc->buflen = 0; if (devc->model != METRAHIT_NONE) { sr_spew("%s %s detected!", VENDOR_GMC, gmc_model_str(devc->model)); sr_sw_limits_init(&devc->limits); sdi->model = g_strdup(gmc_model_str(devc->model)); sdi->version = g_strdup_printf("Firmware %d.%d", devc->fw_ver_maj, devc->fw_ver_min); sdi->conn = serial; sdi->priv = devc; sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P1"); devices = g_slist_append(devices, sdi); devc = g_malloc0(sizeof(struct dev_context)); sdi = g_malloc0(sizeof(struct sr_dev_inst)); sdi->status = SR_ST_INACTIVE; sdi->vendor = g_strdup(VENDOR_GMC); } }; /* Free last alloc if no device found */ if (devc->model == METRAHIT_NONE) { g_free(devc); sr_dev_inst_free(sdi); } return std_scan_complete(di, devices); exit_err: sr_info("scan_2x_bd232(): Error!"); sr_serial_dev_inst_free(serial); g_free(devc); sr_dev_inst_free(sdi); return NULL; }
GError * sqlx_cache_open_and_lock_base(sqlx_cache_t *cache, const hashstr_t *hname, gint *result) { gint bd; GError *err = NULL; sqlx_base_t *base = NULL; EXTRA_ASSERT(cache != NULL); EXTRA_ASSERT(hname != NULL); EXTRA_ASSERT(result != NULL); gint64 start = oio_ext_monotonic_time(); gint64 deadline = DEFAULT_CACHE_OPEN_TIMEOUT; if (cache->open_timeout > 0) deadline = cache->open_timeout; GRID_TRACE2("%s(%p,%s,%p) delay = %"G_GINT64_FORMAT, __FUNCTION__, (void*)cache, hname ? hashstr_str(hname) : "NULL", (void*)result, deadline); deadline += start; g_mutex_lock(&cache->lock); cache->used = TRUE; retry: bd = sqlx_lookup_id(cache, hname); if (bd < 0) { if (!(err = sqlx_base_reserve(cache, hname, &base))) { bd = base->index; *result = base->index; sqlx_base_debug("OPEN", base); } else { GRID_DEBUG("No base available for [%s] (%d %s)", hashstr_str(hname), err->code, err->message); if (sqlx_expire_first_idle_base(cache, 0) >= 0) { g_clear_error(&err); goto retry; } } } else { base = GET(cache, bd); gint64 now = oio_ext_monotonic_time (); if (now > deadline) { err = NEWERROR (CODE_UNAVAILABLE, "DB busy (after %"G_GINT64_FORMAT" ms)", (now - start) / G_TIME_SPAN_MILLISECOND); } else switch (base->status) { case SQLX_BASE_FREE: EXTRA_ASSERT(base->count_open == 0); EXTRA_ASSERT(base->owner == NULL); GRID_ERROR("free base referenced"); g_assert_not_reached(); break; case SQLX_BASE_IDLE: case SQLX_BASE_IDLE_HOT: EXTRA_ASSERT(base->count_open == 0); EXTRA_ASSERT(base->owner == NULL); sqlx_base_move_to_list(cache, base, SQLX_BASE_USED); base->count_open ++; base->owner = g_thread_self(); *result = base->index; break; case SQLX_BASE_USED: EXTRA_ASSERT(base->count_open > 0); EXTRA_ASSERT(base->owner != NULL); if (base->owner != g_thread_self()) { GRID_DEBUG("Base [%s] in use by another thread (%X), waiting...", hashstr_str(hname), oio_log_thread_id(base->owner)); /* The lock is held by another thread/request. XXX(jfs): do not use 'now' because it can be a fake clock */ g_cond_wait_until(base->cond, &cache->lock, g_get_monotonic_time() + oio_cache_period_cond_wait); goto retry; } base->owner = g_thread_self(); base->count_open ++; *result = base->index; break; case SQLX_BASE_CLOSING: EXTRA_ASSERT(base->owner != NULL); /* Just wait for a notification then retry XXX(jfs): do not use 'now' because it can be a fake clock */ g_cond_wait_until(base->cond, &cache->lock, g_get_monotonic_time() + oio_cache_period_cond_wait); goto retry; } } if (base) { if (!err) { sqlx_base_debug(__FUNCTION__, base); EXTRA_ASSERT(base->owner == g_thread_self()); EXTRA_ASSERT(base->count_open > 0); } g_cond_signal(base->cond); } g_mutex_unlock(&cache->lock); return err; }
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { struct drv_context *drvc; struct dev_context *devc; struct sr_datafeed_packet packet; struct sr_datafeed_meta meta; struct sr_config *src; struct sr_usb_dev_inst *usb; GVariant *gvar, *rational[2]; const uint64_t *si; int stored_mqflags, req_len, buf_len, len, ret; unsigned char buf[9]; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; drvc = di->priv; devc = sdi->priv; usb = sdi->conn; devc->cb_data = cb_data; devc->num_samples = 0; /* Send header packet to the session bus. */ std_session_send_df_header(cb_data, LOG_PREFIX); if (devc->data_source == DATA_SOURCE_LIVE) { /* Force configuration. */ kecheng_kc_330b_configure(sdi); if (kecheng_kc_330b_status_get(sdi, &ret) != SR_OK) return SR_ERR; if (ret != DEVICE_ACTIVE) { sr_err("Device is inactive"); /* Still continue though, since the device will * just return 30.0 until the user hits the button * on the device -- and then start feeding good * samples back. */ } } else { if (kecheng_kc_330b_log_info_get(sdi, buf) != SR_OK) return SR_ERR; stored_mqflags = buf[4] ? SR_MQFLAG_SPL_TIME_WEIGHT_S : SR_MQFLAG_SPL_TIME_WEIGHT_F; stored_mqflags |= buf[5] ? SR_MQFLAG_SPL_FREQ_WEIGHT_C : SR_MQFLAG_SPL_FREQ_WEIGHT_A; devc->stored_samples = (buf[7] << 8) | buf[8]; if (devc->stored_samples == 0) { /* Notify frontend of empty log by sending start/end packets. */ packet.type = SR_DF_END; sr_session_send(cb_data, &packet); return SR_OK; } if (devc->limit_samples && devc->limit_samples < devc->stored_samples) devc->stored_samples = devc->limit_samples; si = kecheng_kc_330b_sample_intervals[buf[1]]; rational[0] = g_variant_new_uint64(si[0]); rational[1] = g_variant_new_uint64(si[1]); gvar = g_variant_new_tuple(rational, 2); src = sr_config_new(SR_CONF_SAMPLE_INTERVAL, gvar); packet.type = SR_DF_META; packet.payload = &meta; meta.config = g_slist_append(NULL, src); sr_session_send(devc->cb_data, &packet); g_free(src); } if (!(devc->xfer = libusb_alloc_transfer(0))) return SR_ERR; usb_source_add(drvc->sr_ctx, 10, kecheng_kc_330b_handle_events, (void *)sdi); if (devc->data_source == DATA_SOURCE_LIVE) { buf[0] = CMD_GET_LIVE_SPL; buf_len = 1; devc->state = LIVE_SPL_WAIT; devc->last_live_request = g_get_monotonic_time() / 1000; req_len = 3; } else { buf[0] = CMD_GET_LOG_DATA; buf[1] = 0; buf[2] = 0; buf_len = 4; devc->state = LOG_DATA_WAIT; if (devc->stored_samples < 63) buf[3] = devc->stored_samples; else buf[3] = 63; /* Command ack byte + 2 bytes per sample. */ req_len = 1 + buf[3] * 2; } ret = libusb_bulk_transfer(usb->devhdl, EP_OUT, buf, buf_len, &len, 5); if (ret != 0 || len != 1) { sr_dbg("Failed to start acquisition: %s", libusb_error_name(ret)); libusb_free_transfer(devc->xfer); return SR_ERR; } libusb_fill_bulk_transfer(devc->xfer, usb->devhdl, EP_IN, devc->buf, req_len, kecheng_kc_330b_receive_transfer, (void *)sdi, 15); if (libusb_submit_transfer(devc->xfer) != 0) { libusb_free_transfer(devc->xfer); return SR_ERR; } return SR_OK; }
char *janus_sdp_merge(janus_ice_handle *handle, const char *origsdp) { if(handle == NULL || origsdp == NULL) return NULL; //~ su_home_t home[1] = { SU_HOME_INIT(home) }; sdp_session_t *anon = NULL; sdp_parser_t *parser = sdp_parse(home, origsdp, strlen(origsdp), 0); if(!(anon = sdp_session(parser))) { JANUS_DEBUG("[%"SCNu64"] Error parsing/merging SDP: %s\n", handle->handle_id, sdp_parsing_error(parser)); return NULL; } /* Prepare SDP to merge */ gchar buffer[200]; memset(buffer, 0, 200); char *sdp = (char*)calloc(BUFSIZE, sizeof(char)); if(sdp == NULL) { JANUS_DEBUG("Memory error!\n"); return NULL; } sdp[0] = '\0'; /* Version v= */ g_strlcat(sdp, "v=0\r\n", BUFSIZE); /* Origin o= */ if(anon->sdp_origin) { g_sprintf(buffer, "o=%s %"SCNu64" %"SCNu64" IN IP4 127.0.0.1\r\n", /* FIXME Should we fix the address? */ anon->sdp_origin->o_username ? anon->sdp_origin->o_username : "******", anon->sdp_origin->o_id, anon->sdp_origin->o_version); g_strlcat(sdp, buffer, BUFSIZE); } else { gint64 sessid = g_get_monotonic_time(); gint64 version = sessid; /* FIXME This needs to be increased when it changes, so time should be ok */ g_sprintf(buffer, "o=%s %"SCNi64" %"SCNi64" IN IP4 127.0.0.1\r\n", /* FIXME Should we fix the address? */ "-", sessid, version); g_strlcat(sdp, buffer, BUFSIZE); } /* Session name s= */ g_sprintf(buffer, "s=%s\r\n", anon->sdp_subject ? anon->sdp_subject : "Meetecho Janus"); g_strlcat(sdp, buffer, BUFSIZE); /* Timing t= */ g_sprintf(buffer, "t=%lu %lu\r\n", anon->sdp_time ? anon->sdp_time->t_start : 0, anon->sdp_time ? anon->sdp_time->t_stop : 0); g_strlcat(sdp, buffer, BUFSIZE); /* Any global bandwidth? */ //~ if(anon->sdp_bandwidths) { //~ g_sprintf(buffer, //~ "b=%s:%"SCNu64"\r\n", //~ anon->sdp_bandwidths->b_modifier_name ? anon->sdp_bandwidths->b_modifier_name : "AS", //~ anon->sdp_bandwidths->b_value); //~ g_strlcat(sdp, buffer, BUFSIZE); //~ } /* msid-semantic: add new global attribute */ g_strlcat(sdp, "a=msid-semantic: WMS janus\r\n", BUFSIZE); //~ /* Connection c= (global) */ //~ if(anon->sdp_connection) { //~ g_sprintf(buffer, //~ "c=IN IP4 %s\r\n", janus_get_local_ip()); //~ g_strlcat(sdp, buffer, BUFSIZE); //~ } /* DTLS fingerprint a= (global) */ g_sprintf(buffer, "a=fingerprint:sha-256 %s\r\n", janus_dtls_get_local_fingerprint()); g_strlcat(sdp, buffer, BUFSIZE); /* Copy other global attributes, if any */ if(anon->sdp_attributes) { sdp_attribute_t *a = anon->sdp_attributes; while(a) { if(a->a_value == NULL) { g_sprintf(buffer, "a=%s\r\n", a->a_name); g_strlcat(sdp, buffer, BUFSIZE); } else { g_sprintf(buffer, "a=%s:%s\r\n", a->a_name, a->a_value); g_strlcat(sdp, buffer, BUFSIZE); } a = a->a_next; } } /* Media lines now */ if(anon->sdp_media) { int audio = 0, video = 0; sdp_media_t *m = anon->sdp_media; janus_ice_stream *stream = NULL; while(m) { if(m->m_type == sdp_media_audio) { audio++; if(audio > 1 || !handle->audio_id) { JANUS_DEBUG("[%"SCNu64"] Skipping audio line (we have %d audio lines, and the id is %d)\n", handle->handle_id, audio, handle->audio_id); g_strlcat(sdp, "m=audio 0 RTP/SAVPF 0\r\n", BUFSIZE); m = m->m_next; continue; } /* Audio */ stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(handle->audio_id)); if(stream == NULL) { JANUS_DEBUG("[%"SCNu64"] Skipping audio line (invalid stream %d)\n", handle->handle_id, handle->audio_id); g_strlcat(sdp, "m=audio 0 RTP/SAVPF 0\r\n", BUFSIZE); m = m->m_next; continue; } g_strlcat(sdp, "m=audio ARTPP RTP/SAVPF", BUFSIZE); } else if(m->m_type == sdp_media_video) { video++; if(video > 1 || !handle->video_id) { JANUS_DEBUG("[%"SCNu64"] Skipping video line (we have %d video lines, and the id is %d)\n", handle->handle_id, video, handle->video_id); g_strlcat(sdp, "m=video 0 RTP/SAVPF 0\r\n", BUFSIZE); m = m->m_next; continue; } /* Video */ stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(handle->video_id)); if(stream == NULL) { JANUS_DEBUG("[%"SCNu64"] Skipping video line (invalid stream %d)\n", handle->handle_id, handle->audio_id); g_strlcat(sdp, "m=video 0 RTP/SAVPF 0\r\n", BUFSIZE); m = m->m_next; continue; } g_strlcat(sdp, "m=video VRTPP RTP/SAVPF", BUFSIZE); } else { JANUS_DEBUG("[%"SCNu64"] Skipping unsupported media line...\n", handle->handle_id); g_sprintf(buffer, "m=%s 0 %s 0\r\n", m->m_type_name, m->m_proto_name); g_strlcat(sdp, buffer, BUFSIZE); m = m->m_next; continue; } /* Add formats now */ if(!m->m_rtpmaps) { JANUS_PRINT("[%"SCNu64"] No RTP maps?? trying formats...\n", handle->handle_id); if(!m->m_format) { JANUS_DEBUG("[%"SCNu64"] No formats either?? this sucks!\n", handle->handle_id); g_strlcat(sdp, " 0", BUFSIZE); /* FIXME Won't work apparently */ } else { sdp_list_t *fmt = m->m_format; while(fmt) { g_sprintf(buffer, " %s", fmt->l_text); g_strlcat(sdp, buffer, BUFSIZE); fmt = fmt->l_next; } } } else { sdp_rtpmap_t *r = m->m_rtpmaps; while(r) { g_sprintf(buffer, " %d", r->rm_pt); g_strlcat(sdp, buffer, BUFSIZE); r = r->rm_next; } } g_strlcat(sdp, "\r\n", BUFSIZE); /* Any bandwidth? */ if(m->m_bandwidths) { g_sprintf(buffer, "b=%s:%lu\r\n", /* FIXME Are we doing this correctly? */ m->m_bandwidths->b_modifier_name ? m->m_bandwidths->b_modifier_name : "AS", m->m_bandwidths->b_value); g_strlcat(sdp, buffer, BUFSIZE); } /* Media connection c= */ //~ if(m->m_connections) { g_sprintf(buffer, "c=IN IP4 %s\r\n", janus_get_local_ip()); g_strlcat(sdp, buffer, BUFSIZE); //~ } /* What is the direction? */ switch(m->m_mode) { case sdp_inactive: g_strlcat(sdp, "a=inactive\r\n", BUFSIZE); break; case sdp_sendonly: g_strlcat(sdp, "a=sendonly\r\n", BUFSIZE); break; case sdp_recvonly: g_strlcat(sdp, "a=recvonly\r\n", BUFSIZE); break; case sdp_sendrecv: default: g_strlcat(sdp, "a=sendrecv\r\n", BUFSIZE); break; } /* RTCP */ g_sprintf(buffer, "a=rtcp:%s IN IP4 %s\r\n", m->m_type == sdp_media_audio ? "ARTCP" : "VRTCP", janus_get_local_ip()); g_strlcat(sdp, buffer, BUFSIZE); /* RTP maps */ if(m->m_rtpmaps) { sdp_rtpmap_t *rm = NULL; for(rm = m->m_rtpmaps; rm; rm = rm->rm_next) { g_sprintf(buffer, "a=rtpmap:%u %s/%lu%s%s\r\n", rm->rm_pt, rm->rm_encoding, rm->rm_rate, rm->rm_params ? "/" : "", rm->rm_params ? rm->rm_params : ""); g_strlcat(sdp, buffer, BUFSIZE); } for(rm = m->m_rtpmaps; rm; rm = rm->rm_next) { if(rm->rm_fmtp) { g_sprintf(buffer, "a=fmtp:%u %s\r\n", rm->rm_pt, rm->rm_fmtp); g_strlcat(sdp, buffer, BUFSIZE); } } } /* ICE ufrag and pwd, DTLS setup and connection a= */ gchar *ufrag = NULL; gchar *password = NULL; nice_agent_get_local_credentials(handle->agent, stream->stream_id, &ufrag, &password); memset(buffer, 0, 100); g_sprintf(buffer, "a=ice-ufrag:%s\r\n" "a=ice-pwd:%s\r\n" "a=setup:%s\r\n" "a=connection:new\r\n", ufrag, password, janus_get_dtls_srtp_role(stream->dtls_role)); g_strlcat(sdp, buffer, BUFSIZE); /* Copy existing media attributes, if any */ if(m->m_attributes) { sdp_attribute_t *a = m->m_attributes; while(a) { if(a->a_value == NULL) { g_sprintf(buffer, "a=%s\r\n", a->a_name); g_strlcat(sdp, buffer, BUFSIZE); } else { g_sprintf(buffer, "a=%s:%s\r\n", a->a_name, a->a_value); g_strlcat(sdp, buffer, BUFSIZE); } a = a->a_next; } } /* Add last attributes, rtcp and ssrc (msid) */ if(m->m_type == sdp_media_audio) { g_sprintf(buffer, //~ "a=rtcp:ARTCP IN IP4 %s\r\n" "a=ssrc:%i cname:janusaudio\r\n" "a=ssrc:%i msid:janus janusa0\r\n" "a=ssrc:%i mslabel:janus\r\n" "a=ssrc:%i label:janusa0\r\n", //~ janus_get_local_ip(), stream->ssrc, stream->ssrc, stream->ssrc, stream->ssrc); g_strlcat(sdp, buffer, BUFSIZE); } else if(m->m_type == sdp_media_video) { g_sprintf(buffer, //~ "a=rtcp:VRTCP IN IP4 %s\r\n" "a=ssrc:%i cname:janusvideo\r\n" "a=ssrc:%i msid:janus janusv0\r\n" "a=ssrc:%i mslabel:janus\r\n" "a=ssrc:%i label:janusv0\r\n", //~ janus_get_local_ip(), stream->ssrc, stream->ssrc, stream->ssrc, stream->ssrc); g_strlcat(sdp, buffer, BUFSIZE); } /* And now the candidates */ janus_ice_setup_candidate(handle, sdp, stream->stream_id, 1); janus_ice_setup_candidate(handle, sdp, stream->stream_id, 2); /* Next */ m = m->m_next; } } JANUS_PRINT(" -------------------------------------------\n"); JANUS_PRINT(" >> Merged (%zu --> %zu bytes)\n", strlen(origsdp), strlen(sdp)); JANUS_PRINT(" -------------------------------------------\n"); JANUS_PRINT("%s\n", sdp); return sdp; }
SR_PRIV int motech_lps_30x_receive_data(int fd, int revents, void *cb_data) { struct sr_dev_inst *sdi; struct dev_context *devc; struct sr_serial_dev_inst *serial; int len; (void)fd; if (!(sdi = cb_data)) return TRUE; if (!(devc = sdi->priv)) return TRUE; serial = sdi->conn; if (revents == G_IO_IN) { /* Serial data arrived. */ while (LINELEN_MAX - devc->buflen - 2 > 0) { len = serial_read_nonblocking(serial, devc->buf + devc->buflen, 1); if (len < 1) break; /* Eliminate whitespace at beginning of line. */ if (g_ascii_isspace(devc->buf[0])) { devc->buf[0] = '\0'; devc->buflen = 0; continue; } devc->buflen += len; devc->buf[devc->buflen] = '\0'; /* If line complete, process msg. */ if ((devc->buflen > 0) && ((devc->buf[devc->buflen-1] == '\r') || devc->buf[devc->buflen-1] == '\n')) { devc->buflen--; devc->buf[devc->buflen] = '\0'; sr_spew("Line complete: \"%s\"", devc->buf); process_line(sdi); } } } if (sr_sw_limits_check(&devc->limits)) sdi->driver->dev_acquisition_stop(sdi); /* Only request the next packet if required. */ if (!((sdi->status == SR_ST_ACTIVE) && (devc->acq_running))) return TRUE; if (devc->acq_req_pending) { int64_t elapsed_us = g_get_monotonic_time() - devc->req_sent_at; if (elapsed_us > (REQ_TIMEOUT_MS * 1000)) { sr_spew("Request timeout: req=%d t=%" PRIi64 "us", (int)devc->acq_req, elapsed_us); devc->acq_req_pending = 0; } } if (devc->acq_req_pending == 0) { switch (devc->acq_req) { case AQ_NONE: /* Fall through */ case AQ_STATUS: devc->acq_req = AQ_U1; lps_send_req(serial, "VOUT1"); break; case AQ_U1: devc->acq_req = AQ_I1; lps_send_req(serial, "IOUT1"); break; case AQ_I1: if (devc->model->num_channels == 1) { devc->acq_req = AQ_STATUS; lps_send_req(serial, "STATUS"); } else { devc->acq_req = AQ_U2; lps_send_req(serial, "VOUT2"); } break; case AQ_U2: devc->acq_req = AQ_I2; lps_send_req(serial, "IOUT2"); break; case AQ_I2: devc->acq_req = AQ_STATUS; lps_send_req(serial, "STATUS"); break; default: sr_err("Illegal devc->acq_req=%d", devc->acq_req); return SR_ERR; } devc->req_sent_at = g_get_real_time(); devc->acq_req_pending = 1; } return TRUE; }
static void on_sensor_value_notify(IsSensor *sensor, GParamSpec *pspec, gpointer user_data) { IsDynamicPlugin *self; IsDynamicPluginPrivate *priv; RateData *data; gdouble value, dv, dt, rate; gint64 now; self = IS_DYNAMIC_PLUGIN(user_data); priv = self->priv; value = is_sensor_get_value(sensor); if (value - IS_SENSOR_VALUE_UNSET <= DBL_EPSILON) { is_debug("dynamic", "sensor value for sensor %s is unset - ignoring", is_sensor_get_label(sensor)); goto exit; } now = g_get_monotonic_time(); data = g_object_get_data(G_OBJECT(sensor), DYNAMIC_RATE_DATA_KEY); if (data == NULL) { is_debug("dynamic", "Creating new dynamic rate data for sensor: %s", is_sensor_get_label(sensor)); // allocate data data = g_malloc0(sizeof(*data)); data->rate = 0.0f; data->last_value = value; data->last_time = now; g_object_set_data_full(G_OBJECT(sensor), DYNAMIC_RATE_DATA_KEY, data, g_free); goto exit; } is_debug("dynamic", "Got existing rate data for sensor: %s - rate: %f, last_value %f, last_time %"PRId64"", is_sensor_get_label(sensor), data->rate, data->last_value, data->last_time); dv = value - data->last_value; dt = ((double)(now - data->last_time) / (double)G_USEC_PER_SEC); // convert rate to units per second rate = fabs(dv / dt); is_debug("dynamic", "abs rate of change of sensor %s: %f (t0: %f, t-1: %f, dv: %f, dt: %f)", is_sensor_get_label(sensor), rate, value, data->last_value, dv, dt); // calculate exponentially weighted moving average of rate rate = (EWMA_ALPHA * rate) + ((1 - EWMA_ALPHA) * data->rate); data->rate = rate; data->last_value = value; data->last_time = now; is_debug("dynamic", "EWMA abs rate of change of sensor %s: %f", is_sensor_get_label(sensor), rate); if (rate > priv->max_rate && sensor != priv->max) { // let's see if we can get away without taking a reference on sensor priv->max = sensor; is_message("dynamic", "New highest EWMA rate sensor: %s (rate %f)", is_sensor_get_label(sensor), rate); } if (sensor == priv->max) { priv->max_rate = rate; update_sensor_from_max(self); } exit: return; }
static gboolean gdk_frame_clock_paint_idle (void *data) { GdkFrameClock *clock = GDK_FRAME_CLOCK (data); GdkFrameClockIdle *clock_idle = GDK_FRAME_CLOCK_IDLE (clock); GdkFrameClockIdlePrivate *priv = clock_idle->priv; gboolean skip_to_resume_events; GdkFrameTimings *timings = NULL; priv->paint_idle_id = 0; priv->in_paint_idle = TRUE; priv->min_next_frame_time = 0; skip_to_resume_events = (priv->requested & ~(GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS | GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS)) == 0 && priv->updating_count == 0; if (priv->phase > GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT) { timings = gdk_frame_clock_get_current_timings (clock); } if (!skip_to_resume_events) { switch (priv->phase) { case GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS: break; case GDK_FRAME_CLOCK_PHASE_NONE: case GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT: if (priv->freeze_count == 0) { priv->frame_time = compute_frame_time (clock_idle); _gdk_frame_clock_begin_frame (clock); timings = gdk_frame_clock_get_current_timings (clock); timings->frame_time = priv->frame_time; timings->slept_before = priv->sleep_serial != get_sleep_serial (); priv->phase = GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT; /* We always emit ::before-paint and ::after-paint if * any of the intermediate phases are requested and * they don't get repeated if you freeze/thaw while * in them. */ priv->requested &= ~GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT; g_signal_emit_by_name (G_OBJECT (clock), "before-paint"); priv->phase = GDK_FRAME_CLOCK_PHASE_UPDATE; } /* fallthrough */ case GDK_FRAME_CLOCK_PHASE_UPDATE: if (priv->freeze_count == 0) { if ((priv->requested & GDK_FRAME_CLOCK_PHASE_UPDATE) != 0 || priv->updating_count > 0) { priv->requested &= ~GDK_FRAME_CLOCK_PHASE_UPDATE; g_signal_emit_by_name (G_OBJECT (clock), "update"); } } /* fallthrough */ case GDK_FRAME_CLOCK_PHASE_LAYOUT: if (priv->freeze_count == 0) { int iter; #ifdef G_ENABLE_DEBUG if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0) { if (priv->phase != GDK_FRAME_CLOCK_PHASE_LAYOUT && (priv->requested & GDK_FRAME_CLOCK_PHASE_LAYOUT)) timings->layout_start_time = g_get_monotonic_time (); } #endif /* G_ENABLE_DEBUG */ priv->phase = GDK_FRAME_CLOCK_PHASE_LAYOUT; /* We loop in the layout phase, because we don't want to progress * into the paint phase with invalid size allocations. This may * happen in some situation like races between user window * resizes and natural size changes. */ iter = 0; while ((priv->requested & GDK_FRAME_CLOCK_PHASE_LAYOUT) && priv->freeze_count == 0 && iter++ < 4) { priv->requested &= ~GDK_FRAME_CLOCK_PHASE_LAYOUT; g_signal_emit_by_name (G_OBJECT (clock), "layout"); } if (iter == 5) g_warning ("gdk-frame-clock: layout continuously requested, giving up after 4 tries"); } /* fallthrough */ case GDK_FRAME_CLOCK_PHASE_PAINT: if (priv->freeze_count == 0) { #ifdef G_ENABLE_DEBUG if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0) { if (priv->phase != GDK_FRAME_CLOCK_PHASE_PAINT && (priv->requested & GDK_FRAME_CLOCK_PHASE_PAINT)) timings->paint_start_time = g_get_monotonic_time (); } #endif /* G_ENABLE_DEBUG */ priv->phase = GDK_FRAME_CLOCK_PHASE_PAINT; if (priv->requested & GDK_FRAME_CLOCK_PHASE_PAINT) { priv->requested &= ~GDK_FRAME_CLOCK_PHASE_PAINT; g_signal_emit_by_name (G_OBJECT (clock), "paint"); } } /* fallthrough */ case GDK_FRAME_CLOCK_PHASE_AFTER_PAINT: if (priv->freeze_count == 0) { priv->requested &= ~GDK_FRAME_CLOCK_PHASE_AFTER_PAINT; g_signal_emit_by_name (G_OBJECT (clock), "after-paint"); /* the ::after-paint phase doesn't get repeated on freeze/thaw, */ priv->phase = GDK_FRAME_CLOCK_PHASE_NONE; #ifdef G_ENABLE_DEBUG if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0) timings->frame_end_time = g_get_monotonic_time (); #endif /* G_ENABLE_DEBUG */ } /* fallthrough */ case GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS: ; } } #ifdef G_ENABLE_DEBUG if ((_gdk_debug_flags & GDK_DEBUG_FRAMES) != 0) { if (timings && timings->complete) _gdk_frame_clock_debug_print_timings (clock, timings); } #endif /* G_ENABLE_DEBUG */ if (priv->requested & GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS) { priv->requested &= ~GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS; g_signal_emit_by_name (G_OBJECT (clock), "resume-events"); } if (priv->freeze_count == 0) priv->phase = GDK_FRAME_CLOCK_PHASE_NONE; priv->in_paint_idle = FALSE; /* If there is throttling in the backend layer, then we'll do another * update as soon as the backend unthrottles (if there is work to do), * otherwise we need to figure when the next frame should be. */ if (priv->freeze_count == 0) { priv->min_next_frame_time = compute_min_next_frame_time (clock_idle, priv->frame_time); maybe_start_idle (clock_idle); } if (priv->freeze_count == 0) priv->sleep_serial = get_sleep_serial (); return FALSE; }
static void gb_terminal_respawn (GbTerminalView *self, VteTerminal *terminal) { g_autoptr(GPtrArray) args = NULL; g_autoptr(IdeSubprocess) subprocess = NULL; g_autoptr(IdeSubprocessLauncher) launcher = NULL; g_autofree gchar *workpath = NULL; g_autofree gchar *shell = NULL; GtkWidget *toplevel; GError *error = NULL; IdeContext *context; IdeVcs *vcs; VtePty *pty = NULL; GFile *workdir; gint64 now; int tty_fd = -1; gint stdout_fd = -1; gint stderr_fd = -1; IDE_ENTRY; g_assert (GB_IS_TERMINAL_VIEW (self)); vte_terminal_reset (terminal, TRUE, TRUE); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self)); if (!IDE_IS_WORKBENCH (toplevel)) IDE_EXIT; /* Prevent flapping */ now = g_get_monotonic_time (); if ((now - self->last_respawn) < (G_USEC_PER_SEC / 10)) IDE_EXIT; self->last_respawn = now; context = ide_workbench_get_context (IDE_WORKBENCH (toplevel)); vcs = ide_context_get_vcs (context); workdir = ide_vcs_get_working_directory (vcs); workpath = g_file_get_path (workdir); shell = gb_terminal_view_discover_shell (NULL, &error); if (shell == NULL) { g_warning ("Failed to discover user shell: %s", error->message); /* We prefer bash in flatpak over sh */ if (ide_is_flatpak ()) shell = g_strdup ("/bin/bash"); else shell = vte_get_user_shell (); g_clear_error (&error); } args = g_ptr_array_new (); g_ptr_array_add (args, (gchar *)shell); g_ptr_array_add (args, NULL); pty = vte_terminal_pty_new_sync (terminal, VTE_PTY_DEFAULT | VTE_PTY_NO_LASTLOG | VTE_PTY_NO_UTMP | VTE_PTY_NO_WTMP, NULL, &error); if (pty == NULL) IDE_GOTO (failure); vte_terminal_set_pty (terminal, pty); if (-1 == (tty_fd = gb_vte_pty_create_slave (pty))) IDE_GOTO (failure); /* dup() is safe as it will inherit O_CLOEXEC */ if (-1 == (stdout_fd = dup (tty_fd)) || -1 == (stderr_fd = dup (tty_fd))) IDE_GOTO (failure); /* XXX: It would be nice to allow using the runtimes launcher */ launcher = ide_subprocess_launcher_new (0); ide_subprocess_launcher_set_run_on_host (launcher, TRUE); ide_subprocess_launcher_set_clear_env (launcher, FALSE); ide_subprocess_launcher_set_cwd (launcher, workpath); ide_subprocess_launcher_push_args (launcher, (const gchar * const *)args->pdata); ide_subprocess_launcher_take_stdin_fd (launcher, tty_fd); ide_subprocess_launcher_take_stdout_fd (launcher, stdout_fd); ide_subprocess_launcher_take_stderr_fd (launcher, stderr_fd); ide_subprocess_launcher_setenv (launcher, "TERM", "xterm-256color", TRUE); ide_subprocess_launcher_setenv (launcher, "INSIDE_GNOME_BUILDER", PACKAGE_VERSION, TRUE); ide_subprocess_launcher_setenv (launcher, "SHELL", shell, TRUE); tty_fd = -1; stdout_fd = -1; stderr_fd = -1; if (NULL == (subprocess = ide_subprocess_launcher_spawn (launcher, NULL, &error))) IDE_GOTO (failure); ide_subprocess_wait_async (subprocess, NULL, gb_terminal_view_wait_cb, g_object_ref (terminal)); failure: if (tty_fd != -1) close (tty_fd); if (stdout_fd != -1) close (stdout_fd); g_clear_object (&pty); if (error != NULL) { g_warning ("%s", error->message); g_clear_error (&error); } IDE_EXIT; }
int main(int argc, char *argv[]) { int ser_fd; GError *err = NULL; int werr; gchar *err_info; gint64 data_offset; wtap *w; GOptionContext *opt_ctxt; gint64 ts_start_us = 0; gint64 time_start_us = 0; opt_ctxt = g_option_context_new ("FILE"); g_option_context_add_main_entries(opt_ctxt, app_options, NULL); if (!g_option_context_parse(opt_ctxt, &argc, &argv, &err)) { g_printerr("Failed to parse options: %s\n", err->message); return EXIT_FAILURE; } g_option_context_free(opt_ctxt); w = wtap_open_offline(argv[1], WTAP_TYPE_AUTO, &werr, &err_info, FALSE); if (!w) { g_printerr("Failed to open packet file: %d\n", werr); return EXIT_FAILURE; } if (pseudo) { ser_fd = open_pseudo_terminal(&err); if (ser_fd < 0) { g_printerr("Failed open pseudo terminal: %s\n", err->message); return EXIT_FAILURE; } } else { ser_fd = profibus_serial_open(device, speed, &err); if (ser_fd < 0) { g_printerr("Failed open serial port: %s\n", err->message); return EXIT_FAILURE; } } while(TRUE) { guint8 *data; struct wtap_pkthdr *hdr; if (!wtap_read(w, &werr, &err_info, &data_offset)) { if (err == 0) break; g_printerr("Failed to read packet file: %d\n", werr); return EXIT_FAILURE; } hdr = wtap_phdr(w); data = wtap_buf_ptr(w); if (timing) { if (time_start_us == 0) { ts_start_us = hdr->ts.secs * 1000000LL + hdr->ts.nsecs / 1000; time_start_us = g_get_monotonic_time(); } else { gint64 ts = hdr->ts.secs * 1000000LL + hdr->ts.nsecs / 1000; gint64 next = time_start_us + (ts - ts_start_us); gint64 now = g_get_monotonic_time(); gint64 delay = next - now; if (delay > 0) { poll(NULL, 0, delay / 1000); } } } if (write(ser_fd, data, hdr->len) != hdr->len) { g_printerr("Failed to write to serial device: %s\n", strerror(errno)); break; } /* g_debug("Write %d", hdr->len); */ } wtap_close(w); g_message("EOF"); close(ser_fd); return EXIT_SUCCESS; }
void test_suite_run(TestSuite* suite) { suite->start_time = g_get_monotonic_time(); g_main_loop_run(suite->loop); suite->end_time = g_get_monotonic_time(); }
mt_throws Result updateTime () { LibMary_ThreadLocal * const tlocal = libMary_getThreadLocal(); #ifdef LIBMARY_PLATFORM_WIN32 DWORD const win_time_dw = timeGetTime(); if (tlocal->prv_win_time_dw >= win_time_dw) { tlocal->win_time_offs += 0x100000000; } tlocal->prv_win_time_dw = win_time_dw; DWORD const win_time = win_time_dw + tlocal->win_time_offs; Time const new_seconds = (Time) win_time / 1000; Time const new_microseconds = (Time) win_time * 1000; #else #ifdef __MACH__ mach_timespec_t mts; { #warning TODO call host_get_clock_service only once clock_serv_t clk; host_get_clock_service (mach_host_self(), SYSTEM_CLOCK, &clk); clock_get_time (clk, &mts); mach_port_deallocate (mach_task_self(), clk); } Time const new_seconds = mts.tv_sec; Time const new_microseconds = (Uint64) mts.tv_sec * 1000000 + (Uint64) mts.tv_nsec / 1000; #if 0 // Deprecated gint64 const mono_time = g_get_monotonic_time (); Int64 const mono_time = 0; Time const new_seconds = mono_time / 1000000; Time const new_microseconds = mono_time; #endif #else struct timespec ts; // Note that clock_gettime is well-optimized on Linux x86_64 and does not carry // full syscall overhead (depends on system configuration). int const res = clock_gettime (CLOCK_MONOTONIC, &ts); if (res == -1) { exc_throw (PosixException, errno); exc_push (InternalException, InternalException::BackendError); logE_ (_func, "clock_gettime() failed: ", errnoString (errno)); return Result::Failure; } else if (res != 0) { exc_throw (InternalException, InternalException::BackendError); logE_ (_func, "clock_gettime(): unexpected return value: ", res); return Result::Failure; } logD (time, _func, "tv_sec: ", ts.tv_sec, ", tv_nsec: ", ts.tv_nsec); Time const new_seconds = ts.tv_sec; Time const new_microseconds = (Uint64) ts.tv_sec * 1000000 + (Uint64) ts.tv_nsec / 1000; #endif #endif tlocal->time_log_frac = new_microseconds % 1000000 / 100; if (new_seconds >= tlocal->time_seconds) tlocal->time_seconds = new_seconds; else logW_ (_func, "seconds backwards: ", new_seconds, " (was ", tlocal->time_seconds, ")"); if (new_microseconds >= tlocal->time_microseconds) tlocal->time_microseconds = new_microseconds; else logW_ (_func, "microseconds backwards: ", new_microseconds, " (was ", tlocal->time_microseconds, ")"); logD (time, _func, fmt_hex, tlocal->time_seconds, ", ", tlocal->time_microseconds); if (tlocal->saved_monotime < tlocal->time_seconds || tlocal->saved_unixtime == 0) { // Updading saved unixtime once in a minute. if (tlocal->time_seconds - tlocal->saved_monotime >= 60 || tlocal->saved_unixtime == 0) { // Obtaining current unixtime. This is an extra syscall. tlocal->saved_unixtime = time (NULL); tlocal->saved_monotime = tlocal->time_seconds; } // Updating localtime (broken-down time). time_t const cur_unixtime = tlocal->saved_unixtime + (tlocal->time_seconds - tlocal->saved_monotime); tlocal->unixtime = cur_unixtime; // Note that we call tzset() in libMary_posixInit() for localtime_r() to work correctly. #ifdef LIBMARY_PLATFORM_WIN32 #ifdef LIBMARY_WIN32_SECURE_CRT if (localtime_s (&tlocal->localtime, &cur_unixtime) != 0) logF_ (_func, "localtime_s() failed"); #else libraryLock (); struct tm * const tmp_localtime = localtime (&cur_unixtime); if (tmp_localtime) { tlocal->localtime = *tmp_localtime; } libraryUnlock (); if (!tmp_localtime) logF_ (_func, "localtime() failed"); #endif #else // TODO FIXME This lib function is dog-slow and has huge synchronization overhead. localtime_r (&cur_unixtime, &tlocal->localtime); #endif } // long const timezone_abs = timezone >= 0 ? timezone : -timezone; long const timezone_abs = 0; // tlocal->timezone_str [0] = timezone >= 0 ? '+' : '-'; tlocal->timezone_str [0] = '+'; tlocal->timezone_str [1] = '0' + timezone_abs / 36000; tlocal->timezone_str [2] = '0' + timezone_abs / 3600 % 10; tlocal->timezone_str [3] = '0' + timezone_abs / 600 % 6; tlocal->timezone_str [4] = '0' + timezone_abs / 60 % 10; return Result::Success; }
/** * EscalateSubprocessShutdown: * @self: Subprocess that won't have any more messages sent to it. * @timeout_ms: Maximum time in milliseconds to wait for its stdout to close * before sending SIGKILL to the process. * @error: (out)(allow-none): Error return location or #NULL. * * Returns: #TRUE if stdout closed and had no more messages, or #FALSE if @error * is set and SIGKILL was sent. */ gboolean EscalateSubprocessShutdown(EscalateSubprocess *self, guint timeout_ms, GError **error) { GIOChannel *child_stdout = self->child_stdout; g_assert(child_stdout); GIOStatus status = G_IO_STATUS_ERROR; gint64 start_time = g_get_monotonic_time(); GPollFD poll_fd = { g_io_channel_unix_get_fd(child_stdout), G_IO_IN | G_IO_HUP | G_IO_ERR, 0 }; gchar leftover = '\0'; gsize leftover_length = 0; gboolean result = FALSE; g_assert(self->child_pid); if (self->child_stdin) g_io_channel_unref(self->child_stdin); self->child_stdin = NULL; self->child_stdout = NULL; do { status = g_io_channel_set_flags(child_stdout, G_IO_FLAG_NONBLOCK, NULL); } while (status == G_IO_STATUS_AGAIN); g_assert(status == G_IO_STATUS_NORMAL); do { // Wait for stdout to be readable. gint poll_timeout = timeout_ms - (g_get_monotonic_time() - start_time)/1000; gint poll_result = 0; if (poll_timeout > 0) poll_result = g_poll(&poll_fd, 1, poll_timeout); if (poll_result == 0) { g_set_error(error, ESCALATE_SUBPROCESS_ERROR, ESCALATE_SUBPROCESS_ERROR_SHUTDOWN_TIMEOUT, "Timed out waiting for subprocess to exit"); goto done; } // Try to read one more character so we know if there are any messages // waiting to be read. status = g_io_channel_read_chars(child_stdout, &leftover, 1, &leftover_length, error); } while (status == G_IO_STATUS_AGAIN); switch (status) { case G_IO_STATUS_NORMAL: g_assert(leftover_length == 1); g_set_error(error, ESCALATE_SUBPROCESS_ERROR, ESCALATE_SUBPROCESS_ERROR_LEFTOVER_STDOUT, "Subprocess stdout had unread messages"); break; case G_IO_STATUS_EOF: result = TRUE; break; default: g_assert(!error || *error); } done: if (!result && self->child_pid > 0) { g_assert(kill(self->child_pid, SIGKILL) == 0); self->child_pid = 0; } g_io_channel_unref(child_stdout); return result; }
static int dev_open(struct sr_dev_inst *sdi) { struct sr_dev_driver *di = sdi->driver; struct sr_usb_dev_inst *usb; struct dev_context *devc; int ret; int64_t timediff_us, timediff_ms; devc = sdi->priv; usb = sdi->conn; /* * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS * milliseconds for the FX2 to renumerate. */ ret = SR_ERR; if (devc->fw_updated > 0) { sr_info("Waiting for device to reset."); /* Takes >= 300ms for the FX2 to be gone from the USB bus. */ g_usleep(300 * 1000); timediff_ms = 0; while (timediff_ms < MAX_RENUM_DELAY_MS) { if ((ret = fx2lafw_dev_open(sdi, di)) == SR_OK) break; g_usleep(100 * 1000); timediff_us = g_get_monotonic_time() - devc->fw_updated; timediff_ms = timediff_us / 1000; sr_spew("Waited %" PRIi64 "ms.", timediff_ms); } if (ret != SR_OK) { sr_err("Device failed to renumerate."); return SR_ERR; } sr_info("Device came back after %" PRIi64 "ms.", timediff_ms); } else { sr_info("Firmware upload was not needed."); ret = fx2lafw_dev_open(sdi, di); } if (ret != SR_OK) { sr_err("Unable to open device."); return SR_ERR; } ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE); if (ret != 0) { switch (ret) { case LIBUSB_ERROR_BUSY: sr_err("Unable to claim USB interface. Another " "program or driver has already claimed it."); break; case LIBUSB_ERROR_NO_DEVICE: sr_err("Device has been disconnected."); break; default: sr_err("Unable to claim interface: %s.", libusb_error_name(ret)); break; } return SR_ERR; } if (devc->cur_samplerate == 0) { /* Samplerate hasn't been set; default to the slowest one. */ devc->cur_samplerate = devc->samplerates[0]; } return SR_OK; }
/* * owr_local_media_source_get_pad * * The beginning of a media source chain in the pipeline looks like this: * +------------+ * /---+ inter*sink | * +--------+ +--------+ +------------+ +-----+ / +------------+ * | source +----+ scale? +---+ capsfilter +---+ tee +---/ * +--------+ +--------+ +------------+ +-----+ \ * \ +------------+ * \---+ inter*sink | * +------------+ * * For each newly requested pad a new inter*sink is added to the tee. * Note that this is a completely independent pipeline, and the complete * pipeline is only created once for a specific media source. * * Then for each newly requested pad another bin with a inter*src is * created, which is then going to be part of the transport agent * pipeline. The ghostpad of it is what we return here. * * +-----------+ +-------------------------------+ +----------+ * | inter*src +---+ converters/queues/capsfilters +---+ ghostpad | * +-----------+ +-------------------------------+ +----------+ * */ static GstElement *owr_local_media_source_request_source(OwrMediaSource *media_source, GstCaps *caps) { OwrLocalMediaSource *local_source; OwrLocalMediaSourcePrivate *priv; GstElement *source_element = NULL; GstElement *source_pipeline; GHashTable *event_data; GValue *value; #if defined(__linux__) && !defined(__ANDROID__) gchar *tmp; #endif g_assert(media_source); local_source = OWR_LOCAL_MEDIA_SOURCE(media_source); priv = local_source->priv; /* only create the source bin for this media source once */ if ((source_pipeline = _owr_media_source_get_source_bin(media_source))) GST_DEBUG_OBJECT(media_source, "Re-using existing source element/bin"); else { OwrMediaType media_type = OWR_MEDIA_TYPE_UNKNOWN; OwrSourceType source_type = OWR_SOURCE_TYPE_UNKNOWN; GstElement *source, *source_process = NULL, *capsfilter = NULL, *tee; GstPad *sinkpad, *source_pad; GEnumClass *media_enum_class, *source_enum_class; GEnumValue *media_enum_value, *source_enum_value; gchar *bin_name; GstCaps *source_caps; GstBus *bus; GSource *bus_source; event_data = _owr_value_table_new(); value = _owr_value_table_add(event_data, "start_time", G_TYPE_INT64); g_value_set_int64(value, g_get_monotonic_time()); g_object_get(media_source, "media-type", &media_type, "type", &source_type, NULL); media_enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_MEDIA_TYPE)); source_enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_SOURCE_TYPE)); media_enum_value = g_enum_get_value(media_enum_class, media_type); source_enum_value = g_enum_get_value(source_enum_class, source_type); bin_name = g_strdup_printf("local-%s-%s-source-bin-%u", media_enum_value ? media_enum_value->value_nick : "unknown", source_enum_value ? source_enum_value->value_nick : "unknown", g_atomic_int_add(&unique_bin_id, 1)); g_type_class_unref(media_enum_class); g_type_class_unref(source_enum_class); source_pipeline = gst_pipeline_new(bin_name); gst_pipeline_use_clock(GST_PIPELINE(source_pipeline), gst_system_clock_obtain()); gst_element_set_base_time(source_pipeline, _owr_get_base_time()); gst_element_set_start_time(source_pipeline, GST_CLOCK_TIME_NONE); g_free(bin_name); bin_name = NULL; #ifdef OWR_DEBUG g_signal_connect(source_pipeline, "deep-notify", G_CALLBACK(_owr_deep_notify), NULL); #endif bus = gst_pipeline_get_bus(GST_PIPELINE(source_pipeline)); bus_source = gst_bus_create_watch(bus); g_source_set_callback(bus_source, (GSourceFunc) bus_call, media_source, NULL); g_source_attach(bus_source, _owr_get_main_context()); g_source_unref(bus_source); GST_DEBUG_OBJECT(local_source, "media_type: %d, type: %d", media_type, source_type); if (media_type == OWR_MEDIA_TYPE_UNKNOWN || source_type == OWR_SOURCE_TYPE_UNKNOWN) { GST_ERROR_OBJECT(local_source, "Cannot connect source with unknown type or media type to other component"); goto done; } switch (media_type) { case OWR_MEDIA_TYPE_AUDIO: { switch (source_type) { case OWR_SOURCE_TYPE_CAPTURE: CREATE_ELEMENT(source, AUDIO_SRC, "audio-source"); #if !defined(__APPLE__) || !TARGET_IPHONE_SIMULATOR /* Default values for buffer-time and latency-time on android are 200ms and 20ms. The minimum latency-time that can be used on Android is 20ms, and using a 40ms buffer-time with a 20ms latency-time causes crackling audio. So let's just stick with the defaults. */ #if !defined(__ANDROID__) g_object_set(source, "buffer-time", G_GINT64_CONSTANT(40000), "latency-time", G_GINT64_CONSTANT(10000), NULL); #endif if (priv->device_index > -1) { #ifdef __APPLE__ g_object_set(source, "device", priv->device_index, NULL); #elif defined(__linux__) && !defined(__ANDROID__) tmp = g_strdup_printf("%d", priv->device_index); g_object_set(source, "device", tmp, NULL); g_free(tmp); #endif } #endif break; case OWR_SOURCE_TYPE_TEST: CREATE_ELEMENT(source, "audiotestsrc", "audio-source"); g_object_set(source, "is-live", TRUE, NULL); break; case OWR_SOURCE_TYPE_UNKNOWN: default: g_assert_not_reached(); goto done; } break; } case OWR_MEDIA_TYPE_VIDEO: { GstPad *srcpad; GstCaps *device_caps; switch (source_type) { case OWR_SOURCE_TYPE_CAPTURE: CREATE_ELEMENT(source, VIDEO_SRC, "video-source"); if (priv->device_index > -1) { #if defined(__APPLE__) && !TARGET_IPHONE_SIMULATOR g_object_set(source, "device-index", priv->device_index, NULL); #elif defined(__ANDROID__) g_object_set(source, "cam-index", priv->device_index, NULL); #elif defined(__linux__) tmp = g_strdup_printf("/dev/video%d", priv->device_index); g_object_set(source, "device", tmp, NULL); g_free(tmp); #endif } break; case OWR_SOURCE_TYPE_TEST: { GstElement *src, *time; GstPad *srcpad; source = gst_bin_new("video-source"); CREATE_ELEMENT(src, "videotestsrc", "videotestsrc"); g_object_set(src, "is-live", TRUE, NULL); gst_bin_add(GST_BIN(source), src); time = gst_element_factory_make("timeoverlay", "timeoverlay"); if (time) { g_object_set(time, "font-desc", "Sans 60", NULL); gst_bin_add(GST_BIN(source), time); gst_element_link(src, time); srcpad = gst_element_get_static_pad(time, "src"); } else srcpad = gst_element_get_static_pad(src, "src"); gst_element_add_pad(source, gst_ghost_pad_new("src", srcpad)); gst_object_unref(srcpad); break; } case OWR_SOURCE_TYPE_UNKNOWN: default: g_assert_not_reached(); goto done; } /* First try to see if we can just get the format we want directly */ source_caps = gst_caps_new_empty(); #if GST_CHECK_VERSION(1, 5, 0) gst_caps_foreach(caps, fix_video_caps_framerate, source_caps); #else _owr_gst_caps_foreach(caps, fix_video_caps_framerate, source_caps); #endif /* Now see what the device can really produce */ srcpad = gst_element_get_static_pad(source, "src"); gst_element_set_state(source, GST_STATE_READY); device_caps = gst_pad_query_caps(srcpad, source_caps); if (gst_caps_is_empty(device_caps)) { /* Let's see if it works when we drop format constraints (which can be dealt with downsteram) */ GstCaps *tmp = source_caps; source_caps = gst_caps_new_empty(); #if GST_CHECK_VERSION(1, 5, 0) gst_caps_foreach(tmp, fix_video_caps_format, source_caps); #else _owr_gst_caps_foreach(tmp, fix_video_caps_format, source_caps); #endif gst_caps_unref(tmp); gst_caps_unref(device_caps); device_caps = gst_pad_query_caps(srcpad, source_caps); if (gst_caps_is_empty(device_caps)) { /* Accepting any format didn't work, we're going to hope that scaling fixes it */ CREATE_ELEMENT(source_process, "videoscale", "video-source-scale"); gst_bin_add(GST_BIN(source_pipeline), source_process); } } gst_caps_unref(device_caps); gst_object_unref(srcpad); #if defined(__APPLE__) && TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR /* Force NV12 on iOS else the source can negotiate BGRA * ercolorspace can do NV12 -> BGRA and NV12 -> I420 which is what * is needed for Bowser */ gst_caps_set_simple(source_caps, "format", G_TYPE_STRING, "NV12", NULL); #endif CREATE_ELEMENT(capsfilter, "capsfilter", "video-source-capsfilter"); g_object_set(capsfilter, "caps", source_caps, NULL); gst_caps_unref(source_caps); gst_bin_add(GST_BIN(source_pipeline), capsfilter); break; } case OWR_MEDIA_TYPE_UNKNOWN: default: g_assert_not_reached(); goto done; } g_assert(source); source_pad = gst_element_get_static_pad(source, "src"); g_signal_connect(source_pad, "notify::caps", G_CALLBACK(on_caps), media_source); gst_object_unref(source_pad); CREATE_ELEMENT(tee, "tee", "source-tee"); g_object_set(tee, "allow-not-linked", TRUE, NULL); gst_bin_add_many(GST_BIN(source_pipeline), source, tee, NULL); /* Many sources don't like reconfiguration and it's pointless * here anyway right now. No need to reconfigure whenever something * is added to the tee or removed. * We will have to implement reconfiguration differently later by * selecting the best caps based on all consumers. */ sinkpad = gst_element_get_static_pad(tee, "sink"); gst_pad_add_probe(sinkpad, GST_PAD_PROBE_TYPE_EVENT_UPSTREAM, drop_reconfigure_event, NULL, NULL); gst_object_unref(sinkpad); if (!source) GST_ERROR_OBJECT(media_source, "Failed to create source element!"); if (capsfilter) { LINK_ELEMENTS(capsfilter, tee); if (source_process) { LINK_ELEMENTS(source_process, capsfilter); LINK_ELEMENTS(source, source_process); } else LINK_ELEMENTS(source, capsfilter); } else if (source_process) { LINK_ELEMENTS(source_process, tee); LINK_ELEMENTS(source, source_process); } else LINK_ELEMENTS(source, tee); gst_element_sync_state_with_parent(tee); if (capsfilter) gst_element_sync_state_with_parent(capsfilter); if (source_process) gst_element_sync_state_with_parent(source_process); gst_element_sync_state_with_parent(source); _owr_media_source_set_source_bin(media_source, source_pipeline); _owr_media_source_set_source_tee(media_source, tee); if (gst_element_set_state(source_pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) { GST_ERROR("Failed to set local source pipeline %s to playing", GST_OBJECT_NAME(source_pipeline)); /* FIXME: We should handle this and don't expose the source */ } value = _owr_value_table_add(event_data, "end_time", G_TYPE_INT64); g_value_set_int64(value, g_get_monotonic_time()); OWR_POST_EVENT(media_source, LOCAL_SOURCE_STARTED, event_data); g_signal_connect(tee, "pad-removed", G_CALLBACK(tee_pad_removed_cb), media_source); } gst_object_unref(source_pipeline); source_element = OWR_MEDIA_SOURCE_CLASS(owr_local_media_source_parent_class)->request_source(media_source, caps); done: return source_element; }
static void caja_icon_info_init (CajaIconInfo *icon) { icon->last_use_time = g_get_monotonic_time () * 1000; icon->sole_owner = TRUE; }
void gimp_fonts_load (Gimp *gimp, GimpInitStatusFunc status_callback) { FcConfig *config; GFile *fonts_conf; GList *path; g_return_if_fail (GIMP_IS_FONT_LIST (gimp->fonts)); gimp_set_busy (gimp); if (gimp->be_verbose) g_print ("Loading fonts\n"); gimp_container_freeze (GIMP_CONTAINER (gimp->fonts)); gimp_container_clear (GIMP_CONTAINER (gimp->fonts)); config = FcInitLoadConfig (); if (! config) goto cleanup; fonts_conf = gimp_directory_file (CONF_FNAME, NULL); if (! gimp_fonts_load_fonts_conf (config, fonts_conf)) goto cleanup; fonts_conf = gimp_sysconf_directory_file (CONF_FNAME, NULL); if (! gimp_fonts_load_fonts_conf (config, fonts_conf)) goto cleanup; path = gimp_config_path_expand_to_files (gimp->config->font_path, FALSE); gimp_fonts_add_directories (config, path); g_list_free_full (path, (GDestroyNotify) g_object_unref); if (status_callback) { gint64 end_time; GThread *cache_thread; GimpFontsLoadFuncData data; /* We perform font cache initialization in a separate thread, so * in the case a cache rebuild is to be done it will not block * the UI. */ data.config = config; g_mutex_init (&data.mutex); g_cond_init (&data.cond); data.caching_complete = FALSE; cache_thread = g_thread_new ("font-cacher", (GThreadFunc) gimp_fonts_load_thread, &data); g_mutex_lock (&data.mutex); end_time = g_get_monotonic_time () + 0.1 * G_TIME_SPAN_SECOND; while (! data.caching_complete) if (! g_cond_wait_until (&data.cond, &data.mutex, end_time)) { status_callback (NULL, NULL, 0.6); end_time += 0.1 * G_TIME_SPAN_SECOND; continue; } g_mutex_unlock (&data.mutex); g_thread_join (cache_thread); g_mutex_clear (&data.mutex); g_cond_clear (&data.cond); } else { gimp_fonts_load_func (config); } gimp_font_list_restore (GIMP_FONT_LIST (gimp->fonts)); cleanup: gimp_container_thaw (GIMP_CONTAINER (gimp->fonts)); gimp_unset_busy (gimp); }
/* * Called by libusb (as triggered by handle_event()) when a transfer comes in. * Only channel data comes in asynchronously, and all transfers for this are * queued up beforehand, so this just needs to chuck the incoming data onto * the libsigrok session bus. */ static void LIBUSB_CALL receive_transfer(struct libusb_transfer *transfer) { struct sr_dev_inst *sdi; struct dev_context *devc; sdi = transfer->user_data; devc = sdi->priv; if (devc->dev_state == FLUSH) { g_free(transfer->buffer); libusb_free_transfer(transfer); devc->dev_state = CAPTURE; devc->aq_started = g_get_monotonic_time(); read_channel(sdi, data_amount(sdi)); return; } if (devc->dev_state != CAPTURE) return; if (!devc->sample_buf) { devc->sample_buf_size = 10; devc->sample_buf = g_try_malloc(devc->sample_buf_size * sizeof(transfer)); devc->sample_buf_write = 0; } if (devc->sample_buf_write >= devc->sample_buf_size) { devc->sample_buf_size += 10; devc->sample_buf = g_try_realloc(devc->sample_buf, devc->sample_buf_size * sizeof(transfer)); if (!devc->sample_buf) { sr_err("Sample buffer malloc failed."); devc->dev_state = STOPPING; return; } } devc->sample_buf[devc->sample_buf_write++] = transfer; devc->samp_received += transfer->actual_length / NUM_CHANNELS; sr_spew("receive_transfer(): calculated samplerate == %" PRIu64 "ks/s", (uint64_t)(transfer->actual_length * 1000 / (g_get_monotonic_time() - devc->read_start_ts + 1) / NUM_CHANNELS)); sr_spew("receive_transfer(): status %s received %d bytes.", libusb_error_name(transfer->status), transfer->actual_length); if (transfer->actual_length == 0) /* Nothing to send to the bus. */ return; if (devc->limit_samples && devc->samp_received >= devc->limit_samples) { sr_info("Requested number of samples reached, stopping. %" PRIu64 " <= %" PRIu64, devc->limit_samples, devc->samp_received); send_data(sdi, devc->sample_buf, devc->limit_samples); sdi->driver->dev_acquisition_stop(sdi); } else if (devc->limit_msec && (g_get_monotonic_time() - devc->aq_started) / 1000 >= devc->limit_msec) { sr_info("Requested time limit reached, stopping. %d <= %d", (uint32_t)devc->limit_msec, (uint32_t)(g_get_monotonic_time() - devc->aq_started) / 1000); send_data(sdi, devc->sample_buf, devc->samp_received); g_free(devc->sample_buf); devc->sample_buf = NULL; sdi->driver->dev_acquisition_stop(sdi); } else { read_channel(sdi, data_amount(sdi)); } }
static void test_gpoll (void) { SOCKET sockets[NUM_POLLEES]; GPollFD fds[NUM_POLLFDS]; SOCKET opp_sockets[NUM_POLLEES]; gint i; gint activatable; gint64 times[REPEAT][2]; #define BUCKET_COUNT 25 gint64 bucket_limits[BUCKET_COUNT] = {3, 5, 10, 15, 20, 25, 30, 35, 40, 50, 60, 70, 80, 90, 100, 120, 150, 180, 220, 280, 350, 450, 600, 800, 1000}; gint buckets[BUCKET_COUNT]; gint64 times_avg = 0, times_min = G_MAXINT64, times_max = 0; prepare_sockets (sockets, opp_sockets, fds, NUM_POLLEES); prepare_fds (sockets, fds, NUM_POLLEES); times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); for (i = 0; i < REPEAT; i++) { gint r; gint64 diff; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 0); times[i][1] = g_get_monotonic_time (); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); } times_avg /= NUM_POLLEES; g_print ("\nempty poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); activatable = 0; for (i = 0; i < REPEAT; i++) { gint r, s, v, t; gint64 diff; MSG msg; gboolean found_app; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); s = send (opp_sockets[activatable], (const char *) &t, 1, 0); g_assert (PostMessage (NULL, WM_APP, 1, 2)); /* This is to ensure that all sockets catch up, otherwise some might not poll active */ g_usleep (G_USEC_PER_SEC / 1000); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 1000); times[i][1] = g_get_monotonic_time (); check_fds (sockets, fds, NUM_POLLEES); v = recv (sockets[activatable], (char *) &t, 1, 0); found_app = FALSE; while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2) found_app = TRUE; g_assert (s == 1); g_assert (r == 2); g_assert (v == 1); g_assert (found_app); reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); r = g_poll (fds, NUM_POLLFDS, 0); check_fds (sockets, fds, NUM_POLLEES); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; activatable = (activatable + 1) % NUM_POLLEES; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); } times_avg /= NUM_POLLEES; g_print ("1-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); activatable = 0; for (i = 0; i < REPEAT; i++) { gint r, s, v, t; gint64 diff; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); s = send (opp_sockets[activatable], (const char *) &t, 1, 0); g_usleep (G_USEC_PER_SEC / 1000); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 1000); times[i][1] = g_get_monotonic_time (); check_fds (sockets, fds, NUM_POLLEES); v = recv (sockets[activatable], (char *) &t, 1, 0); g_assert (s == 1); g_assert (r == 1); g_assert (v == 1); reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); r = g_poll (fds, NUM_POLLFDS, 0); check_fds (sockets, fds, NUM_POLLEES); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; activatable = (activatable + 1) % NUM_POLLEES; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); } times_avg /= NUM_POLLEES; g_print ("1-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); for (i = 0; i < REPEAT; i++) { gint r, s, v, t; gint64 diff; gint j; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); s = v = 0; for (j = 0; j < NUM_POLLEES / 2; j++) s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0; g_usleep (G_USEC_PER_SEC / 1000); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 1000); times[i][1] = g_get_monotonic_time (); check_fds (sockets, fds, NUM_POLLEES); for (j = 0; j < NUM_POLLEES / 2; j++) v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0; g_assert (s == NUM_POLLEES / 2); g_assert (r == NUM_POLLEES / 2); g_assert (v == NUM_POLLEES / 2); reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); r = g_poll (fds, NUM_POLLFDS, 0); check_fds (sockets, fds, NUM_POLLEES); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); } times_avg /= NUM_POLLEES; g_print ("half-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); for (i = 0; i < REPEAT; i++) { gint r, s, v, t; gint64 diff; gint j; MSG msg; gboolean found_app; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); s = v = 0; for (j = 0; j < NUM_POLLEES / 2; j++) s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0; g_assert (PostMessage (NULL, WM_APP, 1, 2)); /* This is to ensure that all sockets catch up, otherwise some might not poll active */ g_usleep (G_USEC_PER_SEC / 1000); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 1000); times[i][1] = g_get_monotonic_time (); check_fds (sockets, fds, NUM_POLLEES); for (j = 0; j < NUM_POLLEES / 2; j++) v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0; found_app = FALSE; while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2) found_app = TRUE; g_assert (s == NUM_POLLEES / 2); g_assert (r == NUM_POLLEES / 2 + 1); g_assert (v == NUM_POLLEES / 2); g_assert (found_app); reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); r = g_poll (fds, NUM_POLLFDS, 0); check_fds (sockets, fds, NUM_POLLEES); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); } times_avg /= NUM_POLLEES; g_print ("half-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); for (i = 0; i < REPEAT; i++) { gint r, s, v, t; gint64 diff; gint j; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); s = v = 0; for (j = 0; j < NUM_POLLEES; j++) s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0; g_usleep (G_USEC_PER_SEC / 1000); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 1000); times[i][1] = g_get_monotonic_time (); check_fds (sockets, fds, NUM_POLLEES); for (j = 0; j < NUM_POLLEES; j++) v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0; g_assert (s == NUM_POLLEES); g_assert (r == NUM_POLLEES); g_assert (v == NUM_POLLEES); reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); r = g_poll (fds, NUM_POLLFDS, 0); check_fds (sockets, fds, NUM_POLLEES); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); } times_avg /= NUM_POLLEES; g_print ("%d-socket poll time: \n%4lldns - %4lldns, average %4lldns\n", NUM_POLLEES, times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); activatable = 0; times_avg = 0; times_min = G_MAXINT64; times_max = 0; memset (buckets, 0, sizeof (gint) * BUCKET_COUNT); for (i = 0; i < REPEAT; i++) { gint r, s, v, t; gint64 diff; gint j; MSG msg; gboolean found_app; reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); s = v = 0; for (j = 0; j < activatable; j++) s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0; g_assert (PostMessage (NULL, WM_APP, 1, 2)); g_usleep (G_USEC_PER_SEC / 1000); times[i][0] = g_get_monotonic_time (); r = g_poll (fds, NUM_POLLFDS, 1000); times[i][1] = g_get_monotonic_time (); check_fds (sockets, fds, NUM_POLLEES); for (j = 0; j < activatable; j++) v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0; found_app = FALSE; while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2) found_app = TRUE; g_assert (s == activatable); g_assert (r == activatable + 1); g_assert (v == activatable); g_assert (found_app); reset_fds (fds, NUM_POLLEES); reset_fds_msg (fds, NUM_POLLFDS); r = g_poll (fds, NUM_POLLFDS, 0); check_fds (sockets, fds, NUM_POLLEES); g_assert (r == 0); diff = times[i][1] - times[i][0]; if (times_min > diff) times_min = diff; if (times_max < diff) times_max = diff; times_avg += diff; bucketize (diff, buckets, bucket_limits, BUCKET_COUNT); activatable = (activatable + 1) % NUM_POLLEES; } times_avg /= NUM_POLLEES; g_print ("variable socket number + msg poll time: \n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg); print_buckets (buckets, bucket_limits, BUCKET_COUNT); cleanup_sockets (sockets, opp_sockets, NUM_POLLEES); }
SR_PRIV int norma_dmm_receive_data(int fd, int revents, void *cb_data) { struct sr_dev_inst *sdi; struct dev_context *devc; struct sr_serial_dev_inst *serial; int len; gboolean terminating; gdouble elapsed_s; (void)fd; if (!(sdi = cb_data)) return TRUE; if (!(devc = sdi->priv)) return TRUE; serial = sdi->conn; if (revents == G_IO_IN) { /* Serial data arrived. */ while (NMADMM_BUFSIZE - devc->buflen - 1 > 0) { len = serial_read_nonblocking(serial, devc->buf + devc->buflen, 1); if (len < 1) break; devc->buflen += len; *(devc->buf + devc->buflen) = '\0'; if (*(devc->buf + devc->buflen - 1) == '\n') { /* * TODO: According to specs, should be \r, but * then we'd have to get rid of the \n. */ devc->last_req_pending = FALSE; nma_process_line(sdi); break; } } } /* If number of samples or time limit reached, stop acquisition. */ terminating = FALSE; if (devc->limit_samples && (devc->num_samples >= devc->limit_samples)) { sdi->driver->dev_acquisition_stop(sdi, cb_data); terminating = TRUE; } if (devc->limit_msec) { elapsed_s = g_timer_elapsed(devc->elapsed_msec, NULL); if ((elapsed_s * 1000) >= devc->limit_msec) { sdi->driver->dev_acquisition_stop(sdi, cb_data); terminating = TRUE; } } /* Request next package. */ if (!terminating) { if (devc->last_req_pending) { gint64 elapsed_us = g_get_monotonic_time() - devc->req_sent_at; if (elapsed_us > NMADMM_TIMEOUT_MS * 1000) {/* Timeout! */ sr_spew("Request timeout!"); devc->last_req_pending = FALSE; } } if (!devc->last_req_pending) { if (nma_send_req(sdi, NMADMM_REQ_STATUS, NULL) != SR_OK) return FALSE; } } return TRUE; }
SR_PRIV int bl_acme_receive_data(int fd, int revents, void *cb_data) { uint32_t cur_time, elapsed_time; uint64_t nrexpiration; struct sr_datafeed_packet packet, framep; struct sr_datafeed_analog_old analog; struct sr_dev_inst *sdi; struct sr_channel *ch; struct channel_priv *chp; struct dev_context *devc; GSList *chl, chonly; unsigned i; (void)fd; (void)revents; sdi = cb_data; if (!sdi) return TRUE; devc = sdi->priv; if (!devc) return TRUE; packet.type = SR_DF_ANALOG_OLD; packet.payload = &analog; memset(&analog, 0, sizeof(struct sr_datafeed_analog_old)); if (read(devc->timer_fd, &nrexpiration, sizeof(nrexpiration)) < 0) { sr_warn("Failed to read timer information"); return TRUE; } /* * We were not able to process the previous timer expiration, we are * overloaded. */ if (nrexpiration > 1) devc->samples_missed += nrexpiration - 1; /* * XXX This is a nasty workaround... * * At high sampling rates and maximum channels we are not able to * acquire samples fast enough, even though frontends still think * that samples arrive on time. This causes shifts in frontend * plots. * * To compensate for the delay we check if any clock events were * missed and - if so - don't really read the next value, but send * the same sample as fast as possible. We do it until we are back * on schedule. * * At high sampling rate this doesn't seem to visibly reduce the * accuracy. */ for (i = 0; i < nrexpiration; i++) { framep.type = SR_DF_FRAME_BEGIN; sr_session_send(cb_data, &framep); /* * Due to different units used in each channel we're sending * samples one-by-one. */ for (chl = sdi->channels; chl; chl = chl->next) { ch = chl->data; chp = ch->priv; if (!ch->enabled) continue; chonly.next = NULL; chonly.data = ch; analog.channels = &chonly; analog.num_samples = 1; analog.mq = channel_to_mq(chl->data); analog.unit = channel_to_unit(ch); if (i < 1) chp->val = read_sample(ch); analog.data = &chp->val; sr_session_send(cb_data, &packet); } framep.type = SR_DF_FRAME_END; sr_session_send(cb_data, &framep); } devc->samples_read++; if (devc->limit_samples > 0 && devc->samples_read >= devc->limit_samples) { sr_info("Requested number of samples reached."); sdi->driver->dev_acquisition_stop(sdi, cb_data); devc->last_sample_fin = g_get_monotonic_time(); return TRUE; } else if (devc->limit_msec > 0) { cur_time = g_get_monotonic_time(); elapsed_time = cur_time - devc->start_time; if (elapsed_time >= devc->limit_msec) { sr_info("Sampling time limit reached."); sdi->driver->dev_acquisition_stop(sdi, cb_data); devc->last_sample_fin = g_get_monotonic_time(); return TRUE; } } devc->last_sample_fin = g_get_monotonic_time(); return TRUE; }
static GSList *hw_scan(GSList *options) { struct sr_dev_inst *sdi; const struct dso_profile *prof; struct drv_context *drvc; struct dev_context *devc; GSList *devices; struct libusb_device_descriptor des; libusb_device **devlist; int devcnt, ret, i, j; (void)options; drvc = di->priv; drvc->instances = NULL; devcnt = 0; devices = 0; clear_instances(); /* Find all Hantek DSO devices and upload firmware to all of them. */ libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); for (i = 0; devlist[i]; i++) { if ((ret = libusb_get_device_descriptor(devlist[i], &des))) { sr_err("Failed to get device descriptor: %s.", libusb_error_name(ret)); continue; } prof = NULL; for (j = 0; dev_profiles[j].orig_vid; j++) { if (des.idVendor == dev_profiles[j].orig_vid && des.idProduct == dev_profiles[j].orig_pid) { /* Device matches the pre-firmware profile. */ prof = &dev_profiles[j]; sr_dbg("Found a %s %s.", prof->vendor, prof->model); sdi = dso_dev_new(devcnt, prof); devices = g_slist_append(devices, sdi); devc = sdi->priv; if (ezusb_upload_firmware(devlist[i], USB_CONFIGURATION, prof->firmware) == SR_OK) /* Remember when the firmware on this device was updated */ devc->fw_updated = g_get_monotonic_time(); else sr_err("Firmware upload failed for " "device %d.", devcnt); /* Dummy USB address of 0xff will get overwritten later. */ devc->usb = sr_usb_dev_inst_new( libusb_get_bus_number(devlist[i]), 0xff, NULL); devcnt++; break; } else if (des.idVendor == dev_profiles[j].fw_vid && des.idProduct == dev_profiles[j].fw_pid) { /* Device matches the post-firmware profile. */ prof = &dev_profiles[j]; sr_dbg("Found a %s %s.", prof->vendor, prof->model); sdi = dso_dev_new(devcnt, prof); sdi->status = SR_ST_INACTIVE; devices = g_slist_append(devices, sdi); devc = sdi->priv; devc->usb = sr_usb_dev_inst_new( libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), NULL); devcnt++; break; } } if (!prof) /* not a supported VID/PID */ continue; } libusb_free_device_list(devlist, 1); return devices; }
/* Callback handling data */ static int receive_data(int fd, int revents, const struct sr_dev_inst *sdi) { struct dev_context *devc = sdi->priv; struct sr_datafeed_packet packet; struct sr_datafeed_logic logic; struct sr_datafeed_dso dso; struct sr_datafeed_analog analog; //uint16_t buf[BUFSIZE]; uint16_t *buf; static uint64_t samples_to_send, expected_samplenum, sending_now; int64_t time, elapsed; static uint16_t last_sample = 0; uint16_t cur_sample; int i; (void)fd; (void)revents; if (!(buf = g_try_malloc(BUFSIZE*sizeof(uint16_t)))) { sr_err("buf for receive_data malloc failed."); return FALSE; } /* How many "virtual" samples should we have collected by now? */ time = g_get_monotonic_time(); elapsed = time - devc->starttime; devc->starttime = time; expected_samplenum = elapsed * devc->cur_samplerate / 1000000; /* Of those, how many do we still have to send? */ //samples_to_send = (expected_samplenum - devc->samples_counter) / CONST_LEN * CONST_LEN; samples_to_send = expected_samplenum / CONST_LEN * CONST_LEN; if (devc->limit_samples) { if (sdi->mode == LOGIC) samples_to_send = MIN(samples_to_send, devc->limit_samples - devc->samples_counter); else samples_to_send = MIN(samples_to_send, devc->limit_samples); } while (samples_to_send > 0) { sending_now = MIN(samples_to_send, BUFSIZE); samples_generator(buf, sending_now, devc); if (devc->trigger_stage != 0) { for (i = 0; i < sending_now; i++) { if (devc->trigger_edge == 0) { if ((*(buf + i) | devc->trigger_mask) == (devc->trigger_value | devc->trigger_mask)) { devc->trigger_stage = 0; break; } } else { cur_sample = *(buf + i); if (((last_sample & devc->trigger_edge) == (~devc->trigger_value & devc->trigger_edge)) && ((cur_sample | devc->trigger_mask) == (devc->trigger_value | devc->trigger_mask)) && ((cur_sample & devc->trigger_edge) == (devc->trigger_value & devc->trigger_edge))) { devc->trigger_stage = 0; break; } last_sample = cur_sample; } } if (devc->trigger_stage == 0) { struct ds_trigger_pos demo_trigger_pos; demo_trigger_pos.real_pos = i; packet.type = SR_DF_TRIGGER; packet.payload = &demo_trigger_pos; sr_session_send(sdi, &packet); } } if (devc->trigger_stage == 0){ samples_to_send -= sending_now; if (sdi->mode == LOGIC) { packet.type = SR_DF_LOGIC; packet.payload = &logic; logic.length = sending_now * (NUM_PROBES >> 3); logic.unitsize = (NUM_PROBES >> 3); logic.data = buf; } else if (sdi->mode == DSO) {
static void current_call_view_init(CurrentCallView *view) { gtk_widget_init_template(GTK_WIDGET(view)); CurrentCallViewPrivate *priv = CURRENT_CALL_VIEW_GET_PRIVATE(view); /* create video widget and overlay the call info and controls on it */ priv->video_widget = video_widget_new(); gtk_container_add(GTK_CONTAINER(priv->frame_video), priv->video_widget); gtk_widget_show_all(priv->frame_video); auto stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(priv->video_widget)); auto actor_info = gtk_clutter_actor_new_with_contents(priv->hbox_call_info); auto actor_controls = gtk_clutter_actor_new_with_contents(priv->hbox_call_controls); clutter_actor_add_child(stage, actor_info); clutter_actor_set_x_align(actor_info, CLUTTER_ACTOR_ALIGN_FILL); clutter_actor_set_y_align(actor_info, CLUTTER_ACTOR_ALIGN_START); clutter_actor_add_child(stage, actor_controls); clutter_actor_set_x_align(actor_controls, CLUTTER_ACTOR_ALIGN_CENTER); clutter_actor_set_y_align(actor_controls, CLUTTER_ACTOR_ALIGN_END); /* add fade in and out states to the info and controls */ priv->time_last_mouse_motion = g_get_monotonic_time(); priv->fade_info = create_fade_out_transition(); priv->fade_controls = create_fade_out_transition(); clutter_actor_add_transition(actor_info, "fade_info", priv->fade_info); clutter_actor_add_transition(actor_controls, "fade_controls", priv->fade_controls); clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_info), CLUTTER_TIMELINE_BACKWARD); clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_controls), CLUTTER_TIMELINE_BACKWARD); clutter_timeline_stop(CLUTTER_TIMELINE(priv->fade_info)); clutter_timeline_stop(CLUTTER_TIMELINE(priv->fade_controls)); /* have a timer check every 1 second if the controls should fade out */ priv->timer_fade = g_timeout_add(1000, (GSourceFunc)timeout_check_last_motion_event, view); /* connect to the mouse motion event to reset the last moved time */ g_signal_connect_swapped(priv->video_widget, "motion-notify-event", G_CALLBACK(mouse_moved), view); g_signal_connect_swapped(priv->video_widget, "button-press-event", G_CALLBACK(mouse_moved), view); g_signal_connect_swapped(priv->video_widget, "button-release-event", G_CALLBACK(mouse_moved), view); /* manually handle the focus of the video widget to be able to focus on the call controls */ g_signal_connect(priv->video_widget, "focus", G_CALLBACK(video_widget_focus), view); /* toggle whether or not the chat is displayed */ g_signal_connect(priv->togglebutton_chat, "toggled", G_CALLBACK(chat_toggled), view); /* bind the chat orientation to the gsetting */ priv->settings = g_settings_new_full(get_ring_schema(), NULL, NULL); g_settings_bind_with_mapping(priv->settings, "chat-pane-horizontal", priv->paned_call, "orientation", G_SETTINGS_BIND_GET, map_boolean_to_orientation, nullptr, nullptr, nullptr); g_signal_connect(priv->scalebutton_quality, "value-changed", G_CALLBACK(quality_changed), view); /* customize the quality button scale */ if (auto scale_box = gtk_scale_button_get_box(GTK_SCALE_BUTTON(priv->scalebutton_quality))) { priv->checkbutton_autoquality = gtk_check_button_new_with_label(C_("Enable automatic video quality", "Auto")); gtk_widget_show(priv->checkbutton_autoquality); gtk_box_pack_start(GTK_BOX(scale_box), priv->checkbutton_autoquality, FALSE, TRUE, 0); g_signal_connect(priv->checkbutton_autoquality, "toggled", G_CALLBACK(autoquality_toggled), view); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->checkbutton_autoquality), TRUE); } if (auto scale = gtk_scale_button_get_scale(GTK_SCALE_BUTTON(priv->scalebutton_quality))) { g_signal_connect(scale, "button-press-event", G_CALLBACK(quality_button_pressed), view); g_signal_connect(scale, "button-release-event", G_CALLBACK(quality_button_released), view); } }
void gw_debug(int msgno, const ustring & message, const char *file, int lineno, const char *func) { gint64 milliseconds = (g_get_monotonic_time() / 1000); gw_message("DEBUG:"+std::to_string(msgno)+":"+std::to_string(milliseconds)+"ms: " + message + " " + func + ":" + file + ":" + std::to_string(lineno)); //fsync(1); // flush data to disk }