ArvStream * arv_fake_stream_new (ArvFakeCamera *camera, ArvStreamCallback callback, void *user_data) { ArvFakeStream *fake_stream; ArvFakeStreamThreadData *thread_data; ArvStream *stream; g_return_val_if_fail (ARV_IS_FAKE_CAMERA (camera), NULL); g_object_ref (camera); fake_stream = g_object_new (ARV_TYPE_FAKE_STREAM, NULL); stream = ARV_STREAM (fake_stream); thread_data = g_new (ArvFakeStreamThreadData, 1); thread_data->stream = stream; thread_data->camera = camera; thread_data->callback = callback; thread_data->user_data = user_data; thread_data->cancel = FALSE; thread_data->n_completed_buffers = 0; thread_data->n_failures = 0; thread_data->n_underruns = 0; fake_stream->priv->camera = camera; fake_stream->priv->thread_data = thread_data; fake_stream->priv->thread = arv_g_thread_new ("arv_fake_stream", arv_fake_stream_thread, fake_stream->priv->thread_data); return ARV_STREAM (fake_stream); }
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); }
ArvStream * arv_gv_stream_new (GInetAddress *device_address, guint16 port, ArvStreamCallback callback, void *user_data, guint64 timestamp_tick_frequency, guint packet_size) { ArvGvStream *gv_stream; ArvStream *stream; GInetAddress *incoming_inet_address; ArvGvStreamThreadData *thread_data; g_return_val_if_fail (G_IS_INET_ADDRESS (device_address), NULL); g_return_val_if_fail (packet_size > ARV_GVSP_PACKET_PROTOCOL_OVERHEAD, NULL); gv_stream = g_object_new (ARV_TYPE_GV_STREAM, NULL); stream = ARV_STREAM (gv_stream); gv_stream->socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); incoming_inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4); gv_stream->incoming_address = g_inet_socket_address_new (incoming_inet_address, port); g_object_unref (incoming_inet_address); g_socket_bind (gv_stream->socket, gv_stream->incoming_address, TRUE, NULL); thread_data = g_new (ArvGvStreamThreadData, 1); thread_data->stream = stream; thread_data->callback = callback; thread_data->user_data = user_data; thread_data->socket = gv_stream->socket; thread_data->device_address = g_inet_socket_address_new (device_address, ARV_GVCP_PORT); thread_data->packet_resend = ARV_GV_STREAM_PACKET_RESEND_ALWAYS; thread_data->packet_timeout_us = ARV_GV_STREAM_PACKET_TIMEOUT_US_DEFAULT; thread_data->frame_retention_us = ARV_GV_STREAM_FRAME_RETENTION_US_DEFAULT; thread_data->timestamp_tick_frequency = timestamp_tick_frequency; thread_data->data_size = packet_size - ARV_GVSP_PACKET_PROTOCOL_OVERHEAD; thread_data->cancel = FALSE; thread_data->packet_id = 65300; thread_data->last_frame_id = 0; thread_data->n_completed_buffers = 0; thread_data->n_failures = 0; thread_data->n_underruns = 0; thread_data->n_aborteds = 0; thread_data->n_timeouts = 0; thread_data->n_missing_frames = 0; thread_data->n_size_mismatch_errors = 0; thread_data->n_received_packets = 0; thread_data->n_missing_packets = 0; thread_data->n_error_packets = 0; thread_data->n_ignored_packets = 0; thread_data->n_resent_packets = 0; thread_data->n_resend_requests = 0; thread_data->n_duplicated_packets = 0; thread_data->statistic = arv_statistic_new (1, 5000, 200, 0); thread_data->statistic_count = 0; arv_statistic_set_name (thread_data->statistic, 0, "Buffer reception time"); thread_data->socket_buffer_option = ARV_GV_STREAM_SOCKET_BUFFER_FIXED; thread_data->socket_buffer_size = 0; thread_data->current_socket_buffer_size = 0; gv_stream->thread_data = thread_data; gv_stream->thread = arv_g_thread_new ("arv_gv_stream", arv_gv_stream_thread, gv_stream->thread_data); return ARV_STREAM (gv_stream); }
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; }
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); }