+ sr_session_send(devc->cb_data, &packet);
+}
+
+/*
+ * 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 receive_transfer(struct libusb_transfer *transfer)
+{
+ struct sr_datafeed_packet packet;
+ struct sr_dev_inst *sdi;
+ struct dev_context *devc;
+ int num_samples, pre;
+
+ sdi = transfer->user_data;
+ devc = sdi->priv;
+ sr_spew("receive_transfer(): status %d received %d bytes.",
+ transfer->status, transfer->actual_length);
+
+ if (transfer->actual_length == 0)
+ /* Nothing to send to the bus. */
+ return;
+
+ num_samples = transfer->actual_length / 2;
+
+ sr_spew("Got %d-%d/%d samples in frame.", devc->samp_received + 1,
+ devc->samp_received + num_samples, devc->framesize);
+
+ /*
+ * The device always sends a full frame, but the beginning of the frame
+ * doesn't represent the trigger point. The offset at which the trigger
+ * happened came in with the capture state, so we need to start sending
+ * from there up the session bus. The samples in the frame buffer
+ * before that trigger point came after the end of the device's frame
+ * buffer was reached, and it wrapped around to overwrite up until the
+ * trigger point.
+ */
+ if (devc->samp_received < devc->trigger_offset) {
+ /* Trigger point not yet reached. */
+ if (devc->samp_received + num_samples < devc->trigger_offset) {
+ /* The entire chunk is before the trigger point. */
+ memcpy(devc->framebuf + devc->samp_buffered * 2,
+ transfer->buffer, num_samples * 2);
+ devc->samp_buffered += num_samples;
+ } else {
+ /*
+ * This chunk hits or overruns the trigger point.
+ * Store the part before the trigger fired, and
+ * send the rest up to the session bus.
+ */
+ pre = devc->trigger_offset - devc->samp_received;
+ memcpy(devc->framebuf + devc->samp_buffered * 2,
+ transfer->buffer, pre * 2);
+ devc->samp_buffered += pre;
+
+ /* The rest of this chunk starts with the trigger point. */
+ sr_dbg("Reached trigger point, %d samples buffered.",
+ devc->samp_buffered);
+
+ /* Avoid the corner case where the chunk ended at
+ * exactly the trigger point. */
+ if (num_samples > pre)
+ send_chunk(sdi, transfer->buffer + pre * 2,
+ num_samples - pre);
+ }
+ } else {
+ /* Already past the trigger point, just send it all out. */
+ send_chunk(sdi, transfer->buffer,
+ num_samples);
+ }
+
+ devc->samp_received += num_samples;
+
+ /* Everything in this transfer was either copied to the buffer or
+ * sent to the session bus. */