gint64
arv_chunk_parser_get_integer_value (ArvChunkParser *parser, ArvBuffer *buffer, const char *chunk)
{
ArvGcNode *node;
gint64 value = 0;
g_return_val_if_fail (ARV_IS_CHUNK_PARSER (parser), 0.0);
g_return_val_if_fail (ARV_IS_BUFFER (buffer), 0.0);
node = arv_gc_get_node (parser->priv->genicam, chunk);
arv_gc_set_buffer (parser->priv->genicam, buffer);
if (ARV_IS_GC_INTEGER (node))
value = arv_gc_integer_get_value (ARV_GC_INTEGER (node), NULL);
else
arv_warning_device ("[ArvChunkParser::get_integer_value] Node '%s' is not an integer", chunk);
return value;
}
static void
_open_usb_device (ArvUvDevice *uv_device)
{
libusb_device **devices;
unsigned i, j, k;
ssize_t count;
count = libusb_get_device_list (uv_device->priv->usb, &devices);
if (count < 0) {
arv_warning_device ("[[UvDevice::_open_usb_device] Failed to get USB device list: %s",
libusb_error_name (count));
return;
}
for (i = 0; i < count && uv_device->priv->usb_device == NULL; i++) {
libusb_device_handle *usb_device;
struct libusb_device_descriptor desc;
if (libusb_get_device_descriptor (devices[i], &desc) >= 0 &&
libusb_open (devices[i], &usb_device) == LIBUSB_SUCCESS) {
unsigned char *manufacturer;
unsigned char *product;
unsigned char *serial_nbr;
int index;
manufacturer = g_malloc0 (256);
product = g_malloc0 (256);
serial_nbr = g_malloc0 (256);
index = desc.iManufacturer;
if (index > 0)
libusb_get_string_descriptor_ascii (usb_device, index, manufacturer, 256);
index = desc.iProduct;
if (index > 0)
libusb_get_string_descriptor_ascii (usb_device, index, product, 256);
index = desc.iSerialNumber;
if (index > 0)
libusb_get_string_descriptor_ascii (usb_device, index, serial_nbr, 256);
if (g_strcmp0 ((char * ) manufacturer, uv_device->priv->vendor) == 0 &&
g_strcmp0 ((char * ) product, uv_device->priv->product) == 0 &&
g_strcmp0 ((char * ) serial_nbr, uv_device->priv->serial_nbr) == 0) {
struct libusb_config_descriptor *config;
struct libusb_endpoint_descriptor endpoint;
const struct libusb_interface *inter;
const struct libusb_interface_descriptor *interdesc;
uv_device->priv->usb_device = usb_device;
libusb_get_config_descriptor (devices[i], 0, &config);
for (j = 0; j < (int) config->bNumInterfaces; j++) {
inter = &config->interface[j];
for (k = 0; k < inter->num_altsetting; k++) {
interdesc = &inter->altsetting[k];
if (interdesc->bInterfaceClass == ARV_UV_INTERFACE_INTERFACE_CLASS &&
interdesc->bInterfaceSubClass == ARV_UV_INTERFACE_INTERFACE_SUBCLASS) {
if (interdesc->bInterfaceProtocol == ARV_UV_INTERFACE_CONTROL_PROTOCOL) {
endpoint = interdesc->endpoint[0];
uv_device->priv->control_endpoint = endpoint.bEndpointAddress & 0x0f;
uv_device->priv->control_interface = interdesc->bInterfaceNumber;
}
if (interdesc->bInterfaceProtocol == ARV_UV_INTERFACE_DATA_PROTOCOL) {
endpoint = interdesc->endpoint[0];
uv_device->priv->data_endpoint = endpoint.bEndpointAddress & 0x0f;
uv_device->priv->data_interface = interdesc->bInterfaceNumber;
}
}
}
}
libusb_free_config_descriptor (config);
} else
libusb_close (usb_device);
g_free (manufacturer);
g_free (product);
g_free (serial_nbr);
}
}
libusb_free_device_list (devices, 1);
}
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
}
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);
}
}
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;
}
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 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;
}
if (!gv_device->priv->is_packet_resend_supported)
g_object_set (stream, "packet-resend", ARV_GV_STREAM_PACKET_RESEND_NEVER, NULL);
arv_debug_device ("[GvDevice::create_stream] Stream port = %d", stream_port);
return stream;
}
