static ArvStream *
arv_gv_device_create_stream (ArvDevice *device, ArvStreamCallback callback, void *user_data)
{
ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
ArvGvDeviceIOData *io_data = gv_device->priv->io_data;
ArvStream *stream;
const guint8 *address_bytes;
guint32 stream_port;
guint packet_size;
guint32 n_stream_channels;
GInetAddress *interface_address;
GInetAddress *device_address;
arv_device_read_register (device, ARV_GVBS_N_STREAM_CHANNELS_OFFSET, &n_stream_channels, NULL);
arv_debug_device ("[GvDevice::create_stream] Number of stream channels = %d", n_stream_channels);
if (n_stream_channels < 1)
return NULL;
if (!io_data->is_controller) {
arv_warning_device ("[GvDevice::create_stream] Can't create stream without control access");
return NULL;
}
interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->interface_address));
device_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->device_address));
address_bytes = g_inet_address_to_bytes (interface_address);
/* On some cameras, the default packet size after reset is incorrect.
* So, if the value is obviously incorrect, set it to a default size. */
packet_size = arv_gv_device_get_packet_size (gv_device);
if (packet_size <= ARV_GVSP_PACKET_PROTOCOL_OVERHEAD) {
arv_gv_device_set_packet_size (gv_device, ARV_GV_DEVICE_GVSP_PACKET_SIZE_DEFAULT);
arv_debug_device ("[GvDevice::create_stream] Packet size set to default value (%d)",
ARV_GV_DEVICE_GVSP_PACKET_SIZE_DEFAULT);
}
packet_size = arv_gv_device_get_packet_size (gv_device);
arv_debug_device ("[GvDevice::create_stream] Packet size = %d byte(s)", packet_size);
stream = arv_gv_stream_new (device_address, 0, callback, user_data,
arv_gv_device_get_timestamp_tick_frequency (gv_device), packet_size);
stream_port = arv_gv_stream_get_port (ARV_GV_STREAM (stream));
if (!arv_device_write_register (device, ARV_GVBS_STREAM_CHANNEL_0_IP_ADDRESS_OFFSET,
g_htonl(*((guint32 *) address_bytes)), NULL) ||
!arv_device_write_register (device, ARV_GVBS_STREAM_CHANNEL_0_PORT_OFFSET, stream_port, NULL)) {
arv_warning_device ("[GvDevice::create_stream] Stream configuration failed");
g_object_unref (stream);
return NULL;
}
arv_debug_device ("[GvDevice::create_stream] Stream port = %d", stream_port);
return stream;
}
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;
}
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);
}
