static void
arv_uv_stream_finalize (GObject *object)
{
ArvUvStream *uv_stream = ARV_UV_STREAM (object);
if (uv_stream->priv->thread != NULL) {
ArvUvStreamThreadData *thread_data;
guint64 offset;
guint64 sirm_offset;
guint32 si_control;
thread_data = uv_stream->priv->thread_data;
thread_data->cancel = TRUE;
g_thread_join (uv_stream->priv->thread);
si_control = 0x0;
arv_device_read_memory (ARV_DEVICE (thread_data->uv_device),
ARV_ABRM_SBRM_ADDRESS, sizeof (guint64), &offset, NULL);
arv_device_read_memory (ARV_DEVICE (thread_data->uv_device),
offset + ARV_SBRM_SIRM_ADDRESS, sizeof (guint64), &sirm_offset, NULL);
arv_device_write_memory (ARV_DEVICE (thread_data->uv_device),
sirm_offset + ARV_SI_CONTROL, sizeof (si_control), &si_control, NULL);
g_clear_object (&thread_data->uv_device);
g_free (thread_data);
uv_stream->priv->thread_data = NULL;
uv_stream->priv->thread = NULL;
}
parent_class->finalize (object);
}
void
arv_gv_device_set_packet_size (ArvGvDevice *gv_device, guint packet_size)
{
g_return_if_fail (packet_size > 0);
arv_device_set_integer_feature_value (ARV_DEVICE (gv_device), "GevSCPSPacketSize", packet_size);
}
ArvDevice *
arv_gv_device_new (GInetAddress *interface_address, GInetAddress *device_address)
{
ArvGvDevice *gv_device;
ArvGvDeviceIOData *io_data;
ArvGvDeviceHeartbeatData *heartbeat_data;
char *address_string;
g_return_val_if_fail (G_IS_INET_ADDRESS (interface_address), NULL);
g_return_val_if_fail (G_IS_INET_ADDRESS (device_address), NULL);
address_string = g_inet_address_to_string (interface_address);
arv_debug_device ("[GvDevice::new] Interface address = %s", address_string);
g_free (address_string);
address_string = g_inet_address_to_string (device_address);
arv_debug_device ("[GvDevice::new] Device address = %s", address_string);
g_free (address_string);
gv_device = g_object_new (ARV_TYPE_GV_DEVICE, NULL);
io_data = g_new0 (ArvGvDeviceIOData, 1);
io_data->mutex = g_mutex_new ();
io_data->packet_id = 65300; /* Start near the end of the circular counter */
io_data->interface_address = g_inet_socket_address_new (interface_address, 0);
io_data->device_address = g_inet_socket_address_new (device_address, ARV_GVCP_PORT);
io_data->socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
g_socket_bind (io_data->socket, io_data->interface_address, TRUE, NULL);
io_data->buffer = g_malloc (ARV_GV_DEVICE_BUFFER_SIZE);
io_data->gvcp_n_retries = ARV_GV_DEVICE_GVCP_N_RETRIES_DEFAULT;
io_data->gvcp_timeout_ms = ARV_GV_DEVICE_GVCP_TIMEOUT_MS_DEFAULT;
io_data->poll_in_event.fd = g_socket_get_fd (io_data->socket);
io_data->poll_in_event.events = G_IO_IN;
io_data->poll_in_event.revents = 0;
gv_device->priv->io_data = io_data;
arv_gv_device_load_genicam (gv_device);
arv_gv_device_take_control (gv_device);
heartbeat_data = g_new (ArvGvDeviceHeartbeatData, 1);
heartbeat_data->gv_device = gv_device;
heartbeat_data->io_data = io_data;
heartbeat_data->period_us = ARV_GV_DEVICE_HEARTBEAT_PERIOD_US;
heartbeat_data->cancel = FALSE;
gv_device->priv->heartbeat_data = heartbeat_data;
gv_device->priv->heartbeat_thread = g_thread_create (arv_gv_device_heartbeat_thread,
gv_device->priv->heartbeat_data,
TRUE, NULL);
return ARV_DEVICE (gv_device);
}
ArvDevice *
arv_fake_device_new (const char *serial_number)
{
ArvFakeDevice *fake_device;
g_return_val_if_fail (serial_number != NULL, NULL);
fake_device = g_object_new (ARV_TYPE_FAKE_DEVICE, NULL);
fake_device->priv->camera = arv_fake_camera_new (serial_number);
fake_device->priv->genicam_xml = arv_get_fake_camera_genicam_xml (&fake_device->priv->genicam_xml_size);
fake_device->priv->genicam = arv_gc_new (ARV_DEVICE (fake_device),
fake_device->priv->genicam_xml,
fake_device->priv->genicam_xml_size);
return ARV_DEVICE (fake_device);
}
static gboolean
arv_gv_device_leave_control (ArvGvDevice *gv_device)
{
gboolean success;
gv_device->priv->io_data->is_controller = FALSE;
success = arv_device_write_register (ARV_DEVICE (gv_device),
ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET, 0, NULL);
return success;
}
static void *
arv_gv_device_heartbeat_thread (void *data)
{
ArvGvDeviceHeartbeatData *thread_data = data;
ArvGvDeviceIOData *io_data = thread_data->io_data;
GTimer *timer;
guint32 value;
timer = g_timer_new ();
do {
g_usleep (thread_data->period_us);
if (io_data->is_controller) {
guint counter = 1;
/* TODO: Instead of reading the control register, Pylon does write the heartbeat
* timeout value, which is interresting, as doing this we could get an error
* ack packet which will indicate we lost the control access. */
g_timer_start (timer);
while (!_read_register (io_data, ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET, &value, NULL) &&
g_timer_elapsed (timer, NULL) < ARV_GV_DEVICE_HEARTBEAT_RETRY_TIMEOUT_S &&
!thread_data->cancel) {
g_usleep (ARV_GV_DEVICE_HEARTBEAT_RETRY_DELAY_US);
counter++;
}
if (!thread_data->cancel) {
arv_log_device ("[GvDevice::Heartbeat] Ack value = %d", value);
if (counter > 1)
arv_log_device ("[GvDevice::Heartbeat] Tried %u times", counter);
if ((value & (ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_CONTROL |
ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_EXCLUSIVE)) == 0) {
arv_warning_device ("[GvDevice::Heartbeat] Control access lost");
arv_device_emit_control_lost_signal (ARV_DEVICE (thread_data->gv_device));
io_data->is_controller = FALSE;
}
} else
io_data->is_controller = FALSE;
}
} while (!thread_data->cancel);
g_timer_destroy (timer);
return NULL;
}
guint64
arv_gv_device_get_timestamp_tick_frequency (ArvGvDevice *gv_device)
{
guint32 timestamp_tick_frequency_high;
guint32 timestamp_tick_frequency_low;
g_return_val_if_fail (ARV_IS_GV_DEVICE (gv_device), 0);
if (arv_device_read_register (ARV_DEVICE (gv_device),
ARV_GVBS_TIMESTAMP_TICK_FREQUENCY_HIGH_OFFSET,
×tamp_tick_frequency_high, NULL) &&
arv_device_read_register (ARV_DEVICE (gv_device),
ARV_GVBS_TIMESTAMP_TICK_FREQUENCY_LOW_OFFSET,
×tamp_tick_frequency_low, NULL)) {
guint64 timestamp_tick_frequency;
timestamp_tick_frequency = ((guint64) timestamp_tick_frequency_high << 32) |
timestamp_tick_frequency_low;
return timestamp_tick_frequency;
}
return 0;
}
static void
arv_gv_device_load_genicam (ArvGvDevice *gv_device)
{
const char *genicam;
size_t size;
genicam = arv_gv_device_get_genicam_xml (ARV_DEVICE (gv_device), &size);
if (genicam != NULL) {
gv_device->priv->genicam = arv_gc_new (ARV_DEVICE (gv_device), genicam, size);
arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSPacketSize",
"<Integer Name=\"GevSCPSPacketSize\">"
"<Visibility>Expert</Visibility>"
"<pIsLocked>TLParamsLocked</pIsLocked>"
"<pValue>GevSCPSPacketSizeReg</pValue>"
"</Integer>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSPacketSizeReg",
"<MaskedIntReg Name=\"GevSCPSPacketSizeReg\">"
"<Address>0xd04</Address>"
"<Length>4</Length>"
"<AccessMode>RW</AccessMode>"
"<pPort>Device</pPort>"
"<LSB>31</LSB>"
"<MSB>16</MSB>"
"<Sign>Unsigned</Sign>"
"<Endianess>BigEndian</Endianess>"
"</MaskedIntReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "TLParamsLocked",
"<Integer Name=\"TLParamsLocked\">"
"<Visibility>Invisible</Visibility>"
"<Value>0</Value>"
"<Min>0</Min>"
"<Max>1</Max>"
"</Integer>");
}
}
static gboolean
arv_gv_device_take_control (ArvGvDevice *gv_device)
{
gboolean success;
success = arv_device_write_register (ARV_DEVICE (gv_device),
ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET,
ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_CONTROL, NULL);
gv_device->priv->io_data->is_controller = success;
if (!success)
arv_warning_device ("[GvDevice::take_control] Can't get control access");
return success;
}
ArvDevice *
arv_uv_device_new (const char *vendor, const char *product, const char *serial_nbr)
{
ArvUvDevice *uv_device;
g_return_val_if_fail (vendor != NULL, NULL);
g_return_val_if_fail (product != NULL, NULL);
g_return_val_if_fail (serial_nbr != NULL, NULL);
arv_debug_device ("[UvDevice::new] Vendor = %s", vendor);
arv_debug_device ("[UvDevice::new] Product = %s", product);
arv_debug_device ("[UvDevice::new] S/N = %s", serial_nbr);
uv_device = g_object_new (ARV_TYPE_UV_DEVICE, NULL);
libusb_init (&uv_device->priv->usb);
uv_device->priv->vendor = g_strdup (vendor);
uv_device->priv->product = g_strdup (product);
uv_device->priv->serial_nbr = g_strdup (serial_nbr);
uv_device->priv->packet_id = 65300; /* Start near the end of the circular counter */
uv_device->priv->timeout_ms = 32;
_open_usb_device (uv_device);
arv_debug_device("[UvDevice::new] Using control endpoint %d, interface %d",
uv_device->priv->control_endpoint, uv_device->priv->control_interface);
arv_debug_device("[UvDevice::new] Using data endpoint %d, interface %d",
uv_device->priv->data_endpoint, uv_device->priv->data_interface);
if (uv_device->priv->usb_device == NULL ||
libusb_claim_interface (uv_device->priv->usb_device, uv_device->priv->control_interface) < 0 ||
libusb_claim_interface (uv_device->priv->usb_device, uv_device->priv->data_interface) < 0) {
arv_warning_device ("[UvDevice::new] Failed to claim USB interface to '%s - #%s'", product, serial_nbr);
g_object_unref (uv_device);
return NULL;
}
_bootstrap (uv_device);
if (!ARV_IS_GC (uv_device->priv->genicam)) {
arv_warning_device ("[UvDevice::new] Failed to load genicam data");
g_object_unref (uv_device);
return NULL;
}
return ARV_DEVICE (uv_device);
}
gboolean
arv_uv_device_bulk_transfer (ArvUvDevice *uv_device, ArvUvEndpointType endpoint_type, unsigned char endpoint_flags, void *data,
size_t size, size_t *transferred_size, guint32 timeout_ms, GError **error)
{
gboolean success;
guint8 endpoint;
int transferred = 0;
int result;
g_return_val_if_fail (ARV_IS_UV_DEVICE (uv_device), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (size > 0, FALSE);
if (uv_device->priv->disconnected) {
g_set_error (error, ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_NOT_CONNECTED,
"Not connected");
return FALSE;
}
endpoint = (endpoint_type == ARV_UV_ENDPOINT_CONTROL) ? uv_device->priv->control_endpoint : uv_device->priv->data_endpoint;
result = libusb_bulk_transfer (uv_device->priv->usb_device, endpoint | endpoint_flags, data, size, &transferred,
MAX (uv_device->priv->timeout_ms, timeout_ms));
success = result >= 0;
if (!success)
g_set_error (error, ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TRANSFER_ERROR,
"%s", libusb_error_name (result));
if (transferred_size != NULL)
*transferred_size = transferred;
if (result == LIBUSB_ERROR_NO_DEVICE) {
uv_device->priv->disconnected = TRUE;
arv_device_emit_control_lost_signal (ARV_DEVICE (uv_device));
}
return success;
}
static void
_bootstrap (ArvUvDevice *uv_device)
{
ArvDevice *device = ARV_DEVICE (uv_device);
guint64 offset;
guint32 response_time;
guint64 manifest_table_address;
guint64 device_capability;
guint32 max_cmd_transfer;
guint32 max_ack_transfer;
guint32 u3vcp_capability;
guint64 sirm_offset;
guint32 si_info;
guint32 si_control;
guint64 si_req_payload_size;
guint32 si_req_leader_size;
guint32 si_req_trailer_size;
guint32 si_max_leader_size;
guint32 si_payload_size;
guint32 si_payload_count;
guint32 si_transfer1_size;
guint32 si_transfer2_size;
guint32 si_max_trailer_size;
guint64 manifest_n_entries;
ArvUvcpManifestEntry entry;
ArvUvcpManifestSchemaType schema_type;
GString *string;
void *data;
char manufacturer[64];
arv_debug_device ("Get genicam");
arv_device_read_memory(device, ARV_ABRM_MANUFACTURER_NAME, 64, &manufacturer, NULL);
manufacturer[63] = 0;
arv_debug_device ("MANUFACTURER_NAME = '%s'", manufacturer);
arv_device_read_memory (device, ARV_ABRM_SBRM_ADDRESS, sizeof (guint64), &offset, NULL);
arv_device_read_memory (device, ARV_ABRM_MAX_DEVICE_RESPONSE_TIME, sizeof (guint32), &response_time, NULL);
arv_device_read_memory (device, ARV_ABRM_DEVICE_CAPABILITY, sizeof (guint64), &device_capability, NULL);
arv_device_read_memory (device, ARV_ABRM_MANIFEST_TABLE_ADDRESS, sizeof (guint64), &manifest_table_address, NULL);
arv_debug_device ("MAX_DEVICE_RESPONSE_TIME = 0x%08x", response_time);
arv_debug_device ("DEVICE_CAPABILITY = 0x%016lx", device_capability);
arv_debug_device ("SRBM_ADDRESS = 0x%016lx", offset);
arv_debug_device ("MANIFEST_TABLE_ADDRESS = 0x%016lx", manifest_table_address);
uv_device->priv->timeout_ms = MAX (ARV_UVCP_DEFAULT_RESPONSE_TIME_MS, response_time);
arv_device_read_memory (device, offset + ARV_SBRM_U3VCP_CAPABILITY, sizeof (guint32), &u3vcp_capability, NULL);
arv_device_read_memory (device, offset + ARV_SBRM_MAX_CMD_TRANSFER, sizeof (guint32), &max_cmd_transfer, NULL);
arv_device_read_memory (device, offset + ARV_SBRM_MAX_ACK_TRANSFER, sizeof (guint32), &max_ack_transfer, NULL);
arv_device_read_memory (device, offset + ARV_SBRM_SIRM_ADDRESS, sizeof (guint64), &sirm_offset, NULL);
arv_debug_device ("U3VCP_CAPABILITY = 0x%08x", u3vcp_capability);
arv_debug_device ("MAX_CMD_TRANSFER = 0x%08x", max_cmd_transfer);
arv_debug_device ("MAX_ACK_TRANSFER = 0x%08x", max_ack_transfer);
arv_debug_device ("SIRM_OFFSET = 0x%016lx", sirm_offset);
uv_device->priv->cmd_packet_size_max = MIN (uv_device->priv->cmd_packet_size_max, max_cmd_transfer);
uv_device->priv->ack_packet_size_max = MIN (uv_device->priv->ack_packet_size_max, max_ack_transfer);
arv_device_read_memory (device, sirm_offset + ARV_SI_INFO, sizeof (si_info), &si_info, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_CONTROL, sizeof (si_control), &si_control, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_PAYLOAD_SIZE, sizeof (si_req_payload_size), &si_req_payload_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_LEADER_SIZE, sizeof (si_req_leader_size), &si_req_leader_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_TRAILER_SIZE, sizeof (si_req_trailer_size), &si_req_trailer_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_MAX_LEADER_SIZE, sizeof (si_max_leader_size), &si_max_leader_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_PAYLOAD_SIZE, sizeof (si_payload_size), &si_payload_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_PAYLOAD_COUNT, sizeof (si_payload_count), &si_payload_count, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_TRANSFER1_SIZE, sizeof (si_transfer1_size), &si_transfer1_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_TRANSFER2_SIZE, sizeof (si_transfer2_size), &si_transfer2_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_MAX_TRAILER_SIZE, sizeof (si_max_trailer_size), &si_max_trailer_size, NULL);
arv_debug_device ("SI_INFO = 0x%08x", si_info);
arv_debug_device ("SI_CONTROL = 0x%08x", si_control);
arv_debug_device ("SI_REQ_PAYLOAD_SIZE = 0x%016lx", si_req_payload_size);
arv_debug_device ("SI_REQ_LEADER_SIZE = 0x%08x", si_req_leader_size);
arv_debug_device ("SI_REQ_TRAILER_SIZE = 0x%08x", si_req_trailer_size);
arv_debug_device ("SI_MAX_LEADER_SIZE = 0x%08x", si_max_leader_size);
arv_debug_device ("SI_PAYLOAD_SIZE = 0x%08x", si_payload_size);
arv_debug_device ("SI_PAYLOAD_COUNT = 0x%08x", si_payload_count);
arv_debug_device ("SI_TRANSFER1_SIZE = 0x%08x", si_transfer1_size);
arv_debug_device ("SI_TRANSFER2_SIZE = 0x%08x", si_transfer2_size);
arv_debug_device ("SI_MAX_TRAILER_SIZE = 0x%08x", si_max_trailer_size);
arv_device_read_memory (device, manifest_table_address, sizeof (guint64), &manifest_n_entries, NULL);
arv_device_read_memory (device, manifest_table_address + 0x08, sizeof (entry), &entry, NULL);
arv_debug_device ("MANIFEST_N_ENTRIES = 0x%016lx", manifest_n_entries);
string = g_string_new ("");
arv_g_string_append_hex_dump (string, &entry, sizeof (entry));
arv_debug_device ("MANIFEST ENTRY\n%s", string->str);
g_string_free (string, TRUE);
arv_debug_device ("genicam address = 0x%016lx", entry.address);
arv_debug_device ("genicam size = 0x%016lx", entry.size);
data = g_malloc0 (entry.size);
arv_device_read_memory (device, entry.address, entry.size, data, NULL);
#if 0
string = g_string_new ("");
arv_g_string_append_hex_dump (string, data, entry.size);
arv_debug_device ("GENICAM\n%s", string->str);
g_string_free (string, TRUE);
#endif
schema_type = arv_uvcp_manifest_entry_get_schema_type (&entry);
switch (schema_type) {
case ARV_UVCP_SCHEMA_ZIP:
{
ArvZip *zip;
const GSList *zip_files;
zip = arv_zip_new (data, entry.size);
zip_files = arv_zip_get_file_list (zip);
if (zip_files != NULL) {
const char *zip_filename;
zip_filename = arv_zip_file_get_name (zip_files->data);
uv_device->priv->genicam_xml = arv_zip_get_file (zip,
zip_filename,
&uv_device->priv->genicam_xml_size);
arv_debug_device ("zip file = %s", zip_filename);
#if 0
string = g_string_new ("");
arv_g_string_append_hex_dump (string, uv_device->priv->genicam_xml,
uv_device->priv->genicam_xml_size);
arv_debug_device ("GENICAM\n%s", string->str);
g_string_free (string, TRUE);
#endif
uv_device->priv->genicam = arv_gc_new (ARV_DEVICE (uv_device),
uv_device->priv->genicam_xml,
uv_device->priv->genicam_xml_size);
}
arv_zip_free (zip);
g_free (data);
}
break;
case ARV_UVCP_SCHEMA_RAW:
{
uv_device->priv->genicam_xml = data;
uv_device->priv->genicam_xml_size = entry.size;
uv_device->priv->genicam = arv_gc_new (ARV_DEVICE (uv_device),
uv_device->priv->genicam_xml,
uv_device->priv->genicam_xml_size);
}
break;
default:
arv_warning_device ("Unknown USB3Vision manifest schema type (%d)", schema_type);
}
#if 0
arv_debug_device("GENICAM\n:%s", uv_device->priv->genicam_xml);
#endif
}
ArvStream *
arv_uv_stream_new (ArvUvDevice *uv_device, ArvStreamCallback callback, void *user_data)
{
ArvDevice *device;
ArvUvStream *uv_stream;
ArvUvStreamThreadData *thread_data;
ArvStream *stream;
guint64 offset;
guint64 sirm_offset;
guint64 si_req_payload_size;
guint32 si_req_leader_size;
guint32 si_req_trailer_size;
guint32 si_payload_size;
guint32 si_payload_count;
guint32 si_transfer1_size;
guint32 si_transfer2_size;
guint32 si_control;
g_return_val_if_fail (ARV_IS_UV_DEVICE (uv_device), NULL);
device = ARV_DEVICE (uv_device);
arv_device_read_memory (device, ARV_ABRM_SBRM_ADDRESS, sizeof (guint64), &offset, NULL);
arv_device_read_memory (device, offset + ARV_SBRM_SIRM_ADDRESS, sizeof (guint64), &sirm_offset, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_PAYLOAD_SIZE, sizeof (si_req_payload_size), &si_req_payload_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_LEADER_SIZE, sizeof (si_req_leader_size), &si_req_leader_size, NULL);
arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_TRAILER_SIZE, sizeof (si_req_trailer_size), &si_req_trailer_size, NULL);
arv_debug_stream ("SI_REQ_PAYLOAD_SIZE = 0x%016lx", si_req_payload_size);
arv_debug_stream ("SI_REQ_LEADER_SIZE = 0x%08x", si_req_leader_size);
arv_debug_stream ("SI_REQ_TRAILER_SIZE = 0x%08x", si_req_trailer_size);
si_payload_size = MAXIMUM_TRANSFER_SIZE;
si_payload_count= si_req_payload_size / si_payload_size;
si_transfer1_size = si_req_payload_size % si_payload_size;
si_transfer2_size = 0;
arv_device_write_memory (device, sirm_offset + ARV_SI_MAX_LEADER_SIZE, sizeof (si_req_leader_size), &si_req_leader_size, NULL);
arv_device_write_memory (device, sirm_offset + ARV_SI_MAX_TRAILER_SIZE, sizeof (si_req_trailer_size), &si_req_trailer_size, NULL);
arv_device_write_memory (device, sirm_offset + ARV_SI_PAYLOAD_SIZE, sizeof (si_payload_size), &si_payload_size, NULL);
arv_device_write_memory (device, sirm_offset + ARV_SI_PAYLOAD_COUNT, sizeof (si_payload_count), &si_payload_count, NULL);
arv_device_write_memory (device, sirm_offset + ARV_SI_TRANSFER1_SIZE, sizeof (si_transfer1_size), &si_transfer1_size, NULL);
arv_device_write_memory (device, sirm_offset + ARV_SI_TRANSFER2_SIZE, sizeof (si_transfer2_size), &si_transfer2_size, NULL);
arv_debug_stream ("SI_PAYLOAD_SIZE = 0x%08x", si_payload_size);
arv_debug_stream ("SI_PAYLOAD_COUNT = 0x%08x", si_payload_count);
arv_debug_stream ("SI_TRANSFER1_SIZE = 0x%08x", si_transfer1_size);
arv_debug_stream ("SI_TRANSFER2_SIZE = 0x%08x", si_transfer2_size);
arv_debug_stream ("SI_MAX_LEADER_SIZE = 0x%08x", si_req_leader_size);
arv_debug_stream ("SI_MAX_TRAILER_SIZE = 0x%08x", si_req_trailer_size);
si_control = 0x1;
arv_device_write_memory (device, sirm_offset + ARV_SI_CONTROL, sizeof (si_control), &si_control, NULL);
uv_stream = g_object_new (ARV_TYPE_UV_STREAM, NULL);
stream = ARV_STREAM (uv_stream);
thread_data = g_new (ArvUvStreamThreadData, 1);
thread_data->uv_device = g_object_ref (uv_device);
thread_data->stream = stream;
thread_data->callback = callback;
thread_data->user_data = user_data;
thread_data->cancel = FALSE;
thread_data->leader_size = si_req_leader_size;
thread_data->payload_size = si_payload_size;
thread_data->trailer_size = si_req_trailer_size;
thread_data->n_completed_buffers = 0;
thread_data->n_failures = 0;
thread_data->n_underruns = 0;
uv_stream->priv->thread_data = thread_data;
uv_stream->priv->thread = arv_g_thread_new ("arv_uv_stream", arv_uv_stream_thread, uv_stream->priv->thread_data);
return ARV_STREAM (uv_stream);
}
ArvDevice *
arv_gv_device_new (GInetAddress *interface_address, GInetAddress *device_address)
{
ArvGvDevice *gv_device;
ArvGvDeviceIOData *io_data;
ArvGvDeviceHeartbeatData *heartbeat_data;
ArvGcRegisterDescriptionNode *register_description;
ArvDomDocument *document;
char *address_string;
guint32 capabilities;
g_return_val_if_fail (G_IS_INET_ADDRESS (interface_address), NULL);
g_return_val_if_fail (G_IS_INET_ADDRESS (device_address), NULL);
address_string = g_inet_address_to_string (interface_address);
arv_debug_device ("[GvDevice::new] Interface address = %s", address_string);
g_free (address_string);
address_string = g_inet_address_to_string (device_address);
arv_debug_device ("[GvDevice::new] Device address = %s", address_string);
g_free (address_string);
gv_device = g_object_new (ARV_TYPE_GV_DEVICE, NULL);
io_data = g_new0 (ArvGvDeviceIOData, 1);
#if GLIB_CHECK_VERSION(2,32,0)
g_mutex_init (&io_data->mutex);
#else
io_data->mutex = g_mutex_new ();
#endif
io_data->packet_id = 65300; /* Start near the end of the circular counter */
io_data->interface_address = g_inet_socket_address_new (interface_address, 0);
io_data->device_address = g_inet_socket_address_new (device_address, ARV_GVCP_PORT);
io_data->socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
g_socket_bind (io_data->socket, io_data->interface_address, TRUE, NULL);
io_data->buffer = g_malloc (ARV_GV_DEVICE_BUFFER_SIZE);
io_data->gvcp_n_retries = ARV_GV_DEVICE_GVCP_N_RETRIES_DEFAULT;
io_data->gvcp_timeout_ms = ARV_GV_DEVICE_GVCP_TIMEOUT_MS_DEFAULT;
io_data->poll_in_event.fd = g_socket_get_fd (io_data->socket);
io_data->poll_in_event.events = G_IO_IN;
io_data->poll_in_event.revents = 0;
gv_device->priv->io_data = io_data;
arv_gv_device_load_genicam (gv_device);
arv_gv_device_take_control (gv_device);
heartbeat_data = g_new (ArvGvDeviceHeartbeatData, 1);
heartbeat_data->gv_device = gv_device;
heartbeat_data->io_data = io_data;
heartbeat_data->period_us = ARV_GV_DEVICE_HEARTBEAT_PERIOD_US;
heartbeat_data->cancel = FALSE;
gv_device->priv->heartbeat_data = heartbeat_data;
gv_device->priv->heartbeat_thread = arv_g_thread_new ("arv_gv_heartbeat", arv_gv_device_heartbeat_thread,
gv_device->priv->heartbeat_data);
arv_device_read_register (ARV_DEVICE (gv_device), ARV_GVBS_GVCP_CAPABILITY_OFFSET, &capabilities, NULL);
gv_device->priv->is_packet_resend_supported = (capabilities & ARV_GVBS_GVCP_CAPABILITY_PACKET_RESEND) != 0;
gv_device->priv->is_write_memory_supported = (capabilities & ARV_GVBS_GVCP_CAPABILITY_WRITE_MEMORY) != 0;
arv_debug_device ("[GvDevice::new] Packet resend = %s", gv_device->priv->is_packet_resend_supported ? "yes" : "no");
arv_debug_device ("[GvDevice::new] Write memory = %s", gv_device->priv->is_write_memory_supported ? "yes" : "no");
document = ARV_DOM_DOCUMENT (gv_device->priv->genicam);
register_description = ARV_GC_REGISTER_DESCRIPTION_NODE (arv_dom_document_get_document_element (document));
if (!arv_gc_register_description_node_check_schema_version (register_description, 1, 1, 0))
arv_debug_device ("[GvDevice::new] Register workaround = yes");
return ARV_DEVICE (gv_device);
}
guint
arv_gv_device_get_packet_size (ArvGvDevice *gv_device)
{
return arv_device_get_integer_feature_value (ARV_DEVICE (gv_device), "GevSCPSPacketSize");
}
static char *
_load_genicam (ArvGvDevice *gv_device, guint32 address, size_t *size)
{
char filename[ARV_GVBS_XML_URL_SIZE];
char **tokens;
char *genicam = NULL;
g_return_val_if_fail (size != NULL, NULL);
*size = 0;
if (!arv_device_read_memory (ARV_DEVICE (gv_device), address, ARV_GVBS_XML_URL_SIZE, filename, NULL))
return NULL;
filename[ARV_GVBS_XML_URL_SIZE - 1] = '\0';
arv_debug_device ("[GvDevice::load_genicam] xml url = '%s' at 0x%x", filename, address);
tokens = g_regex_split (arv_gv_device_get_url_regex (), filename, 0);
if (tokens[0] != NULL) {
if (g_strcmp0 (tokens[1], "File:") == 0)
g_file_get_contents (filename, &genicam, NULL, NULL);
else if (g_strcmp0 (tokens[1], "Local:") == 0 &&
tokens[2] != NULL &&
tokens[3] != NULL &&
tokens[4] != NULL) {
guint32 file_address;
guint32 file_size;
file_address = strtoul (tokens[3], NULL, 16);
file_size = strtoul (tokens[4], NULL, 16);
arv_debug_device ("[GvDevice::load_genicam] Xml address = 0x%x - size = 0x%x - %s",
file_address, file_size, tokens[2]);
if (file_size > 0) {
genicam = g_malloc (file_size);
if (arv_device_read_memory (ARV_DEVICE (gv_device), file_address, file_size,
genicam, NULL)) {
genicam [file_size - 1] = '\0';
if (g_str_has_suffix (tokens[2], ".zip")) {
ArvZip *zip;
const GSList *zip_files;
arv_debug_device ("[GvDevice::load_genicam] Zipped xml data");
zip = arv_zip_new (genicam, file_size);
zip_files = arv_zip_get_file_list (zip);
if (zip_files != NULL) {
const char *zip_filename;
void *tmp_buffer;
size_t tmp_buffer_size;
zip_filename = arv_zip_file_get_name (zip_files->data);
tmp_buffer = arv_zip_get_file (zip, zip_filename,
&tmp_buffer_size);
g_free (genicam);
file_size = tmp_buffer_size;
genicam = tmp_buffer;
} else
arv_warning_device ("[GvDevice::load_genicam] Invalid format");
arv_zip_free (zip);
}
*size = file_size;
} else {
g_free (genicam);
genicam = NULL;
*size = 0;
}
}
}
}
g_strfreev (tokens);
return genicam;
}
static void
arv_gv_device_load_genicam (ArvGvDevice *gv_device)
{
const char *genicam;
size_t size;
genicam = arv_gv_device_get_genicam_xml (ARV_DEVICE (gv_device), &size);
if (genicam != NULL) {
gv_device->priv->genicam = arv_gc_new (ARV_DEVICE (gv_device), genicam, size);
arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceVendorName",
"<StringReg Name=\"DeviceVendorName\">"
"<DisplayName>Vendor Name</DisplayName>"
"<Address>0x48</Address>"
"<Length>32</Length>"
"<AccessMode>RO</AccessMode>"
"<pPort>Device</pPort>"
"</StringReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceModelName",
"<StringReg Name=\"DeviceModelName\">"
"<DisplayName>Model Name</DisplayName>"
"<Address>0x68</Address>"
"<Length>32</Length>"
"<AccessMode>RO</AccessMode>"
"<pPort>Device</pPort>"
"</StringReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceVersion",
"<StringReg Name=\"DeviceVersion\">"
"<DisplayName>Device Version</DisplayName>"
"<Address>0x88</Address>"
"<Length>32</Length>"
"<AccessMode>RO</AccessMode>"
"<pPort>Device</pPort>"
"</StringReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceManufacturerInfo",
"<StringReg Name=\"DeviceManufacturerInfo\">"
"<DisplayName>Manufacturer Info</DisplayName>"
"<Address>0xa8</Address>"
"<Length>48</Length>"
"<AccessMode>RO</AccessMode>"
"<pPort>Device</pPort>"
"</StringReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceID",
"<StringReg Name=\"DeviceID\">"
"<DisplayName>Device ID</DisplayName>"
"<Address>0xd8</Address>"
"<Length>16</Length>"
"<AccessMode>RO</AccessMode>"
"<pPort>Device</pPort>"
"</StringReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSPacketSize",
"<Integer Name=\"GevSCPSPacketSize\">"
"<Visibility>Expert</Visibility>"
"<pIsLocked>TLParamsLocked</pIsLocked>"
"<pValue>GevSCPSPacketSizeReg</pValue>"
"</Integer>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSPacketSizeReg",
"<MaskedIntReg Name=\"GevSCPSPacketSizeReg\">"
"<Address>0xd04</Address>"
"<Length>4</Length>"
"<AccessMode>RW</AccessMode>"
"<pPort>Device</pPort>"
"<LSB>31</LSB>"
"<MSB>16</MSB>"
"<Sign>Unsigned</Sign>"
"<Endianess>BigEndian</Endianess>"
"</MaskedIntReg>");
arv_gc_set_default_node_data (gv_device->priv->genicam, "TLParamsLocked",
"<Integer Name=\"TLParamsLocked\">"
"<Visibility>Invisible</Visibility>"
"<Value>0</Value>"
"<Min>0</Min>"
"<Max>1</Max>"
"</Integer>");
}
}
