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);
}
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;
}
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);
}
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
}
static gboolean
_write_memory (ArvUvDevice *uv_device, guint64 address, guint32 size, void *buffer, GError **error)
{
ArvUvcpPacket *packet;
void *read_packet;
size_t packet_size;
size_t read_packet_size;
gboolean success = FALSE;
unsigned n_tries = 0;
guint32 timeout_ms = 0;
read_packet_size = arv_uvcp_packet_get_write_memory_ack_size ();
if (read_packet_size > uv_device->priv->ack_packet_size_max) {
arv_debug_device ("Invalid acknowledge packet size (%d / max: %d)",
read_packet_size, uv_device->priv->ack_packet_size_max);
return FALSE;
}
packet = arv_uvcp_packet_new_write_memory_cmd (address, size, 0, &packet_size);
if (packet_size > uv_device->priv->cmd_packet_size_max) {
arv_debug_device ("Invalid command packet size (%d / max: %d)", packet_size, uv_device->priv->cmd_packet_size_max);
arv_uvcp_packet_free (packet);
return FALSE;
}
memcpy (arv_uvcp_packet_get_write_memory_cmd_data (packet), buffer, size);
read_packet = g_malloc (read_packet_size);
do {
GError *error = NULL;
size_t transferred;
uv_device->priv->packet_id = arv_uvcp_next_packet_id (uv_device->priv->packet_id);
arv_uvcp_packet_set_packet_id (packet, uv_device->priv->packet_id);
arv_uvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
success = TRUE;
success = success && arv_uv_device_bulk_transfer (uv_device, ARV_UV_ENDPOINT_CONTROL, LIBUSB_ENDPOINT_OUT,
packet, packet_size, NULL, 0, &error);
if (success ) {
gboolean expected_answer;
do {
success = TRUE;
success = success && arv_uv_device_bulk_transfer (uv_device, ARV_UV_ENDPOINT_CONTROL, LIBUSB_ENDPOINT_IN,
read_packet, read_packet_size, &transferred,
timeout_ms, &error);
if (success) {
ArvUvcpPacketType packet_type;
ArvUvcpCommand command;
guint16 packet_id;
packet_type = arv_uvcp_packet_get_packet_type (read_packet);
command = arv_uvcp_packet_get_command (read_packet);
packet_id = arv_uvcp_packet_get_packet_id (read_packet);
if (command == ARV_UVCP_COMMAND_PENDING_ACK) {
expected_answer = FALSE;
timeout_ms = arv_uvcp_packet_get_pending_ack_timeout (read_packet);
arv_log_device ("[UvDevice::write_memory] Pending ack timeout = %d", timeout_ms);
} else
expected_answer = packet_type == ARV_UVCP_PACKET_TYPE_ACK &&
command == ARV_UVCP_COMMAND_WRITE_MEMORY_ACK &&
packet_id == uv_device->priv->packet_id;
} else {
expected_answer = FALSE;
if (error != NULL)
g_warning ("[UvDevice::write_memory] Ack reception error: %s", error->message);
g_clear_error (&error);
}
} while (success && !expected_answer);
success = success && expected_answer;
if (success)
arv_uvcp_packet_debug (read_packet, ARV_DEBUG_LEVEL_LOG);
} else {
if (error != NULL)
g_warning ("[UvDevice::write_memory] Command sending error: %s", error->message);
g_clear_error (&error);
}
n_tries++;
} while (!success && n_tries < ARV_UV_DEVICE_N_TRIES_MAX);
g_free (read_packet);
arv_uvcp_packet_free (packet);
if (!success) {
if (error != NULL && *error == NULL)
*error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
"[ArvDevice::write_memory] Timeout");
}
return success;
}
void
handle_control_packet (ArvFakeGvCamera *gv_camera, GSocket *socket,
GSocketAddress *remote_address,
ArvGvcpPacket *packet, size_t size)
{
ArvGvcpPacket *ack_packet = NULL;
size_t ack_packet_size;
guint32 block_address;
guint32 block_size;
guint16 packet_id;
guint32 register_address;
guint32 register_value;
gboolean write_access;
if (gv_camera->controller_address != NULL) {
struct timespec time;
guint64 elapsed_ms;
clock_gettime (CLOCK_MONOTONIC, &time);
elapsed_ms = 1000 * (time.tv_sec - gv_camera->controller_time.tv_sec) +
(time.tv_nsec - gv_camera->controller_time.tv_nsec) / 1000000;
if (elapsed_ms > arv_fake_camera_get_heartbeat_timeout (gv_camera->camera)) {
g_object_ref (gv_camera->controller_address);
gv_camera->controller_address = NULL;
write_access = TRUE;
arv_warning_device ("[FakeGvCamera::handle_control_packet] Heartbeat timeout");
arv_fake_camera_set_control_channel_privilege (gv_camera->camera, 0);
} else
write_access = _g_inet_socket_address_is_equal
(G_INET_SOCKET_ADDRESS (remote_address),
G_INET_SOCKET_ADDRESS (gv_camera->controller_address));
} else
write_access = TRUE;
arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
packet_id = arv_gvcp_packet_get_packet_id (packet);
switch (g_ntohs (packet->header.command)) {
case ARV_GVCP_COMMAND_DISCOVERY_CMD:
ack_packet = arv_gvcp_packet_new_discovery_ack (&ack_packet_size);
arv_debug_device ("[FakeGvCamera::handle_control_packet] Discovery command");
arv_fake_camera_read_memory (gv_camera->camera, 0, ARV_GVBS_DISCOVERY_DATA_SIZE,
&ack_packet->data);
break;
case ARV_GVCP_COMMAND_READ_MEMORY_CMD:
arv_gvcp_packet_get_read_memory_cmd_infos (packet, &block_address, &block_size);
arv_debug_device ("[FakeGvCamera::handle_control_packet] Read memory command %d (%d)",
block_address, block_size);
ack_packet = arv_gvcp_packet_new_read_memory_ack (block_address, block_size,
packet_id, &ack_packet_size);
arv_fake_camera_read_memory (gv_camera->camera, block_address, block_size,
arv_gvcp_packet_get_read_memory_ack_data (ack_packet));
break;
case ARV_GVCP_COMMAND_WRITE_MEMORY_CMD:
if (!write_access)
break;
arv_gvcp_packet_get_write_memory_cmd_infos (packet, &block_address, &block_size);
arv_debug_device ("[FakeGvCamera::handle_control_packet] Write memory command %d (%d)",
block_address, block_size);
arv_fake_camera_write_memory (gv_camera->camera, block_address, block_size,
arv_gvcp_packet_get_write_memory_cmd_data (packet));
ack_packet = arv_gvcp_packet_new_write_memory_ack (block_address, packet_id,
&ack_packet_size);
break;
case ARV_GVCP_COMMAND_READ_REGISTER_CMD:
arv_gvcp_packet_get_read_register_cmd_infos (packet, ®ister_address);
arv_fake_camera_read_register (gv_camera->camera, register_address, ®ister_value);
arv_debug_device ("[FakeGvCamera::handle_control_packet] Read register command %d -> %d",
register_address, register_value);
ack_packet = arv_gvcp_packet_new_read_register_ack (register_value, packet_id,
&ack_packet_size);
if (register_address == ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET)
clock_gettime (CLOCK_MONOTONIC, &gv_camera->controller_time);
break;
case ARV_GVCP_COMMAND_WRITE_REGISTER_CMD:
if (!write_access)
break;
arv_gvcp_packet_get_write_register_cmd_infos (packet, ®ister_address, ®ister_value);
arv_fake_camera_write_register (gv_camera->camera, register_address, register_value);
arv_debug_device ("[FakeGvCamera::handle_control_packet] Write register command %d -> %d",
register_address, register_value);
ack_packet = arv_gvcp_packet_new_write_register_ack (register_value, packet_id,
&ack_packet_size);
break;
default:
arv_warning_device ("[FakeGvCamera::handle_control_packet] Unknown command");
}
if (ack_packet != NULL) {
g_socket_send_to (socket, remote_address, (char *) ack_packet, ack_packet_size, NULL, NULL);
arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
g_free (ack_packet);
}
if (gv_camera->controller_address == NULL &&
arv_fake_camera_get_control_channel_privilege (gv_camera->camera) != 0) {
g_object_ref (remote_address);
gv_camera->controller_address = remote_address;
clock_gettime (CLOCK_MONOTONIC, &gv_camera->controller_time);
}
}
ArvFakeGvCamera *
arv_fake_gv_camera_new (const char *interface_name)
{
ArvFakeGvCamera *gv_camera;
struct ifaddrs *ifap = NULL;
struct ifaddrs *ifap_iter;
int return_value;
gboolean interface_found = FALSE;
gboolean binding_error = FALSE;
g_return_val_if_fail (interface_name != NULL, NULL);
gv_camera = g_new0 (ArvFakeGvCamera, 1);
gv_camera->camera = arv_fake_camera_new ("GV01");
return_value = getifaddrs (&ifap);
if (return_value < 0) {
g_warning ("[FakeGvCamera::new] No network interface found");
return NULL;
}
for (ifap_iter = ifap ;ifap_iter != NULL && !interface_found; ifap_iter = ifap_iter->ifa_next) {
if ((ifap_iter->ifa_flags & IFF_UP) != 0 &&
(ifap_iter->ifa_flags & IFF_POINTOPOINT) == 0 &&
(ifap_iter->ifa_addr->sa_family == AF_INET) &&
g_strcmp0 (ifap_iter->ifa_name, interface_name) == 0) {
GSocketAddress *socket_address;
GSocketAddress *inet_socket_address;
GInetAddress *inet_address;
char *gvcp_address_string;
char *discovery_address_string;
socket_address = g_socket_address_new_from_native (ifap_iter->ifa_addr,
sizeof (struct sockaddr));
inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address));
gvcp_address_string = g_inet_address_to_string (inet_address);
arv_debug_device ("[FakeGvCamera::new] Interface address = %s", gvcp_address_string);
inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT);
gv_camera->gvcp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_camera->gvcp_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_socket_set_blocking (gv_camera->gvcp_socket, FALSE);
arv_fake_camera_set_inet_address (gv_camera->camera, inet_address);
g_object_unref (inet_socket_address);
inet_socket_address = g_inet_socket_address_new (inet_address, 0);
gv_camera->gvsp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_camera->gvsp_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_object_unref (inet_socket_address);
g_object_unref (socket_address);
socket_address = g_socket_address_new_from_native (ifap_iter->ifa_broadaddr,
sizeof (struct sockaddr));
inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address));
discovery_address_string = g_inet_address_to_string (inet_address);
arv_debug_device ("[FakeGvCamera::new] Discovery address = %s", discovery_address_string);
inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT);
if (g_strcmp0 (gvcp_address_string, discovery_address_string) == 0)
gv_camera->discovery_socket = NULL;
else {
gv_camera->discovery_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_camera->discovery_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_socket_set_blocking (gv_camera->discovery_socket, FALSE);
}
g_object_unref (inet_socket_address);
g_object_unref (socket_address);
g_free (gvcp_address_string);
g_free (discovery_address_string);
gv_camera->gvcp_fds[0].fd = g_socket_get_fd (gv_camera->gvcp_socket);
gv_camera->gvcp_fds[0].events = G_IO_IN;
gv_camera->gvcp_fds[0].revents = 0;
if (gv_camera->discovery_socket != NULL) {
gv_camera->gvcp_fds[1].fd = g_socket_get_fd (gv_camera->discovery_socket);
gv_camera->gvcp_fds[1].events = G_IO_IN;
gv_camera->gvcp_fds[1].revents = 0;
gv_camera->n_gvcp_fds = 2;
} else
gv_camera->n_gvcp_fds = 1;
interface_found = TRUE;
}
}
freeifaddrs (ifap);
if (binding_error)
goto BINDING_ERROR;
if (!interface_found)
goto INTERFACE_ERROR;
gv_camera->cancel = FALSE;
gv_camera->gvsp_thread = arv_g_thread_new ("arv_fake_gv_camera", arv_fake_gv_camera_thread, gv_camera);
return gv_camera;
BINDING_ERROR:
g_object_unref (gv_camera->gvcp_socket);
if (gv_camera->discovery_socket != NULL)
g_object_unref (gv_camera->discovery_socket);
g_object_unref (gv_camera->gvsp_socket);
INTERFACE_ERROR:
g_object_unref (gv_camera->camera);
g_free (gv_camera);
return NULL;
}
gboolean
handle_control_packet (ArvGvFakeCamera *gv_fake_camera, GSocket *socket,
GSocketAddress *remote_address,
ArvGvcpPacket *packet, size_t size)
{
ArvGvcpPacket *ack_packet = NULL;
size_t ack_packet_size;
guint32 block_address;
guint32 block_size;
guint16 packet_id;
guint16 packet_type;
guint32 register_address;
guint32 register_value;
gboolean write_access;
gboolean success = FALSE;
if (gv_fake_camera->priv->controller_address != NULL) {
gint64 time;
guint64 elapsed_ms;
time = g_get_real_time ();
elapsed_ms = (time - gv_fake_camera->priv->controller_time) / 1000;
if (elapsed_ms > arv_fake_camera_get_heartbeat_timeout (gv_fake_camera->priv->camera)) {
g_object_unref (gv_fake_camera->priv->controller_address);
gv_fake_camera->priv->controller_address = NULL;
write_access = TRUE;
arv_warning_device ("[GvFakeCamera::handle_control_packet] Heartbeat timeout");
arv_fake_camera_set_control_channel_privilege (gv_fake_camera->priv->camera, 0);
} else
write_access = _g_inet_socket_address_is_equal
(G_INET_SOCKET_ADDRESS (remote_address),
G_INET_SOCKET_ADDRESS (gv_fake_camera->priv->controller_address));
} else
write_access = TRUE;
arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
packet_id = arv_gvcp_packet_get_packet_id (packet);
packet_type = arv_gvcp_packet_get_packet_type (packet);
if (packet_type != ARV_GVCP_PACKET_TYPE_CMD) {
arv_warning_device ("[GvFakeCamera::handle_control_packet] Unknown packet type");
return FALSE;
}
switch (g_ntohs (packet->header.command)) {
case ARV_GVCP_COMMAND_DISCOVERY_CMD:
ack_packet = arv_gvcp_packet_new_discovery_ack (&ack_packet_size);
arv_debug_device ("[GvFakeCamera::handle_control_packet] Discovery command");
arv_fake_camera_read_memory (gv_fake_camera->priv->camera, 0, ARV_GVBS_DISCOVERY_DATA_SIZE,
&ack_packet->data);
break;
case ARV_GVCP_COMMAND_READ_MEMORY_CMD:
arv_gvcp_packet_get_read_memory_cmd_infos (packet, &block_address, &block_size);
arv_debug_device ("[GvFakeCamera::handle_control_packet] Read memory command %d (%d)",
block_address, block_size);
ack_packet = arv_gvcp_packet_new_read_memory_ack (block_address, block_size,
packet_id, &ack_packet_size);
arv_fake_camera_read_memory (gv_fake_camera->priv->camera, block_address, block_size,
arv_gvcp_packet_get_read_memory_ack_data (ack_packet));
break;
case ARV_GVCP_COMMAND_WRITE_MEMORY_CMD:
arv_gvcp_packet_get_write_memory_cmd_infos (packet, &block_address, &block_size);
if (!write_access) {
arv_warning_device("[GvFakeCamera::handle_control_packet] Ignore Write memory command %d (%d) not controller",
block_address, block_size);
break;
}
arv_debug_device ("[GvFakeCamera::handle_control_packet] Write memory command %d (%d)",
block_address, block_size);
arv_fake_camera_write_memory (gv_fake_camera->priv->camera, block_address, block_size,
arv_gvcp_packet_get_write_memory_cmd_data (packet));
ack_packet = arv_gvcp_packet_new_write_memory_ack (block_address, packet_id,
&ack_packet_size);
break;
case ARV_GVCP_COMMAND_READ_REGISTER_CMD:
arv_gvcp_packet_get_read_register_cmd_infos (packet, ®ister_address);
arv_fake_camera_read_register (gv_fake_camera->priv->camera, register_address, ®ister_value);
arv_debug_device ("[GvFakeCamera::handle_control_packet] Read register command %d -> %d",
register_address, register_value);
ack_packet = arv_gvcp_packet_new_read_register_ack (register_value, packet_id,
&ack_packet_size);
if (register_address == ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET)
gv_fake_camera->priv->controller_time = g_get_real_time ();
break;
case ARV_GVCP_COMMAND_WRITE_REGISTER_CMD:
arv_gvcp_packet_get_write_register_cmd_infos (packet, ®ister_address, ®ister_value);
if (!write_access) {
arv_warning_device("[GvFakeCamera::handle_control_packet] Ignore Write register command %d (%d) not controller",
register_address, register_value);
break;
}
arv_fake_camera_write_register (gv_fake_camera->priv->camera, register_address, register_value);
arv_debug_device ("[GvFakeCamera::handle_control_packet] Write register command %d -> %d",
register_address, register_value);
ack_packet = arv_gvcp_packet_new_write_register_ack (1, packet_id,
&ack_packet_size);
break;
default:
arv_warning_device ("[GvFakeCamera::handle_control_packet] Unknown command");
}
if (ack_packet != NULL) {
g_socket_send_to (socket, remote_address, (char *) ack_packet, ack_packet_size, NULL, NULL);
arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
g_free (ack_packet);
success = TRUE;
}
if (gv_fake_camera->priv->controller_address == NULL &&
arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) != 0) {
g_object_ref (remote_address);
arv_debug_device("[GvFakeCamera::handle_control_packet] New controller");
gv_fake_camera->priv->controller_address = remote_address;
gv_fake_camera->priv->controller_time = g_get_real_time ();
}
else if (gv_fake_camera->priv->controller_address != NULL &&
arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) == 0) {
g_object_unref (gv_fake_camera->priv->controller_address);
arv_debug_device("[GvFakeCamera::handle_control_packet] Controller releases");
gv_fake_camera->priv->controller_address = NULL;
gv_fake_camera->priv->controller_time = g_get_real_time ();
}
return success;
}
gboolean
arv_gv_fake_camera_start (ArvGvFakeCamera *gv_fake_camera)
{
struct ifaddrs *ifap = NULL;
struct ifaddrs *ifap_iter;
int return_value;
gboolean interface_found = FALSE;
gboolean binding_error = FALSE;
g_return_val_if_fail (ARV_IS_GV_FAKE_CAMERA (gv_fake_camera), FALSE);
return_value = getifaddrs (&ifap);
if (return_value < 0) {
arv_warning_device ("[GvFakeCamera::start] No network interface found");
return FALSE;
}
for (ifap_iter = ifap ;ifap_iter != NULL && !interface_found; ifap_iter = ifap_iter->ifa_next) {
if ((ifap_iter->ifa_flags & IFF_UP) != 0 &&
(ifap_iter->ifa_flags & IFF_POINTOPOINT) == 0 &&
(ifap_iter->ifa_addr->sa_family == AF_INET) &&
g_strcmp0 (ifap_iter->ifa_name, gv_fake_camera->priv->interface_name) == 0) {
GSocketAddress *socket_address;
GSocketAddress *inet_socket_address;
GInetAddress *inet_address;
char *gvcp_address_string;
char *discovery_address_string;
socket_address = g_socket_address_new_from_native (ifap_iter->ifa_addr,
sizeof (struct sockaddr));
inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address));
gvcp_address_string = g_inet_address_to_string (inet_address);
arv_debug_device ("[GvFakeCamera::start] Interface address = %s", gvcp_address_string);
inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT);
gv_fake_camera->priv->gvcp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_fake_camera->priv->gvcp_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_socket_set_blocking (gv_fake_camera->priv->gvcp_socket, FALSE);
arv_fake_camera_set_inet_address (gv_fake_camera->priv->camera, inet_address);
g_object_unref (inet_socket_address);
inet_socket_address = g_inet_socket_address_new (inet_address, 0);
gv_fake_camera->priv->gvsp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_fake_camera->priv->gvsp_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_clear_object (&inet_socket_address);
g_clear_object (&socket_address);
inet_address = g_inet_address_new_from_string ("255.255.255.255");
discovery_address_string = g_inet_address_to_string (inet_address);
arv_debug_device ("[GvFakeCamera::start] Discovery address = %s", discovery_address_string);
inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT);
if (g_strcmp0 (gvcp_address_string, discovery_address_string) == 0)
gv_fake_camera->priv->discovery_socket = NULL;
else {
gv_fake_camera->priv->discovery_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_fake_camera->priv->discovery_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_socket_set_blocking (gv_fake_camera->priv->discovery_socket, FALSE);
}
g_clear_object (&inet_socket_address);
g_clear_object (&inet_address);
g_free (gvcp_address_string);
g_free (discovery_address_string);
gv_fake_camera->priv->gvcp_fds[0].fd = g_socket_get_fd (gv_fake_camera->priv->gvcp_socket);
gv_fake_camera->priv->gvcp_fds[0].events = G_IO_IN;
gv_fake_camera->priv->gvcp_fds[0].revents = 0;
if (gv_fake_camera->priv->discovery_socket != NULL) {
gv_fake_camera->priv->gvcp_fds[1].fd = g_socket_get_fd (gv_fake_camera->priv->discovery_socket);
gv_fake_camera->priv->gvcp_fds[1].events = G_IO_IN;
gv_fake_camera->priv->gvcp_fds[1].revents = 0;
gv_fake_camera->priv->n_gvcp_fds = 2;
} else
gv_fake_camera->priv->n_gvcp_fds = 1;
interface_found = TRUE;
}
}
freeifaddrs (ifap);
if (binding_error) {
g_clear_object (&gv_fake_camera->priv->gvcp_socket);
g_clear_object (&gv_fake_camera->priv->gvsp_socket);
g_clear_object (&gv_fake_camera->priv->discovery_socket);
return FALSE;
}
if (!interface_found) {
return FALSE;
}
gv_fake_camera->priv->cancel = FALSE;
gv_fake_camera->priv->thread = g_thread_new ("arv_fake_gv_fake_camera", _thread, gv_fake_camera);
return TRUE;
}
void *
_thread (void *user_data)
{
ArvGvFakeCamera *gv_fake_camera = user_data;
ArvBuffer *image_buffer = NULL;
GError *error = NULL;
GSocketAddress *stream_address = NULL;
void *packet_buffer;
size_t packet_size;
size_t payload = 0;
guint16 block_id;
ptrdiff_t offset;
guint32 gv_packet_size;
GInputVector input_vector;
int n_events;
gboolean is_streaming = FALSE;
input_vector.buffer = g_malloc0 (ARV_GV_FAKE_CAMERA_BUFFER_SIZE);
input_vector.size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE;
packet_buffer = g_malloc (ARV_GV_FAKE_CAMERA_BUFFER_SIZE);
do {
guint64 next_timestamp_us;
guint64 sleep_time_us;
if (is_streaming) {
sleep_time_us = arv_fake_camera_get_sleep_time_for_next_frame (gv_fake_camera->priv->camera, &next_timestamp_us);
} else {
sleep_time_us = 100000;
next_timestamp_us = g_get_real_time () + sleep_time_us;
}
do {
gint timeout_ms;
timeout_ms = MIN (100, (next_timestamp_us - g_get_real_time ()) / 1000LL);
if (timeout_ms < 0)
timeout_ms = 0;
n_events = g_poll (gv_fake_camera->priv->gvcp_fds, 2, timeout_ms);
if (n_events > 0) {
GSocketAddress *remote_address = NULL;
int count;
count = g_socket_receive_message (gv_fake_camera->priv->gvcp_socket,
&remote_address, &input_vector, 1, NULL, NULL,
NULL, NULL, NULL);
if (count > 0) {
if (handle_control_packet (gv_fake_camera, gv_fake_camera->priv->gvcp_socket,
remote_address, input_vector.buffer, count))
arv_debug_device ("[GvFakeCamera::thread] Control packet received");
}
g_clear_object (&remote_address);
if (gv_fake_camera->priv->discovery_socket != NULL) {
count = g_socket_receive_message (gv_fake_camera->priv->discovery_socket,
&remote_address, &input_vector, 1, NULL, NULL,
NULL, NULL, NULL);
if (count > 0) {
if (handle_control_packet (gv_fake_camera, gv_fake_camera->priv->discovery_socket,
remote_address, input_vector.buffer, count))
arv_debug_device ("[GvFakeCamera::thread]"
" Control packet received on discovery socket\n");
}
g_clear_object (&remote_address);
}
if (arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) == 0 ||
arv_fake_camera_get_acquisition_status (gv_fake_camera->priv->camera) == 0) {
if (stream_address != NULL) {
g_object_unref (stream_address);
stream_address = NULL;
g_object_unref (image_buffer);
image_buffer = NULL;
arv_debug_stream_thread ("[GvFakeCamera::thread] Stop stream");
}
is_streaming = FALSE;
}
}
} while (!g_atomic_int_get (&gv_fake_camera->priv->cancel) && g_get_real_time () < next_timestamp_us);
if (arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) != 0 &&
arv_fake_camera_get_acquisition_status (gv_fake_camera->priv->camera) != 0) {
if (stream_address == NULL) {
GInetAddress *inet_address;
char *inet_address_string;
stream_address = arv_fake_camera_get_stream_address (gv_fake_camera->priv->camera);
inet_address = g_inet_socket_address_get_address
(G_INET_SOCKET_ADDRESS (stream_address));
inet_address_string = g_inet_address_to_string (inet_address);
arv_debug_stream_thread ("[GvFakeCamera::thread] Start stream to %s (%d)",
inet_address_string,
g_inet_socket_address_get_port
(G_INET_SOCKET_ADDRESS (stream_address)));
g_free (inet_address_string);
payload = arv_fake_camera_get_payload (gv_fake_camera->priv->camera);
image_buffer = arv_buffer_new (payload, NULL);
}
arv_fake_camera_fill_buffer (gv_fake_camera->priv->camera, image_buffer, &gv_packet_size);
arv_debug_stream_thread ("[GvFakeCamera::thread] Send frame %d", image_buffer->priv->frame_id);
block_id = 0;
packet_size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE;
arv_gvsp_packet_new_data_leader (image_buffer->priv->frame_id,
block_id,
image_buffer->priv->timestamp_ns,
image_buffer->priv->pixel_format,
image_buffer->priv->width, image_buffer->priv->height,
image_buffer->priv->x_offset, image_buffer->priv->y_offset,
packet_buffer, &packet_size);
g_socket_send_to (gv_fake_camera->priv->gvsp_socket, stream_address,
packet_buffer, packet_size, NULL, &error);
if (error != NULL) {
arv_warning_stream_thread ("[GvFakeCamera::thread] Failed to send leader for frame %d: %s",
image_buffer->priv->frame_id, error->message);
g_clear_error (&error);
}
block_id++;
offset = 0;
while (offset < payload) {
size_t data_size;
data_size = MIN (gv_packet_size - ARV_GVSP_PACKET_PROTOCOL_OVERHEAD,
payload - offset);
packet_size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE;
arv_gvsp_packet_new_data_block (image_buffer->priv->frame_id, block_id,
data_size, ((char *) image_buffer->priv->data) + offset,
packet_buffer, &packet_size);
g_socket_send_to (gv_fake_camera->priv->gvsp_socket, stream_address,
packet_buffer, packet_size, NULL, &error);
if (error != NULL) {
arv_debug_stream_thread ("[GvFakeCamera::thread] Failed to send frame block %d for frame: %s",
block_id,
image_buffer->priv->frame_id,
error->message);
g_clear_error (&error);
}
offset += data_size;
block_id++;
}
packet_size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE;
arv_gvsp_packet_new_data_trailer (image_buffer->priv->frame_id, block_id,
packet_buffer, &packet_size);
g_socket_send_to (gv_fake_camera->priv->gvsp_socket, stream_address,
packet_buffer, packet_size, NULL, &error);
if (error != NULL) {
arv_debug_stream_thread ("[GvFakeCamera::thread] Failed to send trailer for frame %d: %s",
image_buffer->priv->frame_id,
error->message);
g_clear_error (&error);
}
is_streaming = TRUE;
}
} while (!g_atomic_int_get (&gv_fake_camera->priv->cancel));
if (stream_address != NULL)
g_object_unref (stream_address);
if (image_buffer != NULL)
g_object_unref (image_buffer);
g_free (packet_buffer);
g_free (input_vector.buffer);
return NULL;
}
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;
}
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);
}