1 /* Aravis - Digital camera library
2 *
3 * Copyright © 2009-2016 Emmanuel Pacaud
4 *
5 * This library is distributed in the hope that it will be useful,
6 * but WITHOUT ANY WARRANTY; without even the implied warranty of
7 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
8 * Lesser General Public License for more details.
9 *
10 * You should have received a copy of the GNU Lesser General
11 * Public License along with this library; if not, write to the
12 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
13 * Boston, MA 02110-1301, USA.
14 *
15 * Author: Emmanuel Pacaud <emmanuel@gnome.org>
16 */
17
18 /**
19 * SECTION: arvgvdevice
20 * @short_description: GigEVision device
21 */
22
23 #include <sys/param.h>
24
25 #include <arvgvdeviceprivate.h>
26 #include <arvdeviceprivate.h>
27 #include <arvgc.h>
28 #include <arvgccommand.h>
29 #include <arvgcboolean.h>
30 #include <arvgcregisterdescriptionnode.h>
31 #include <arvdebug.h>
32 #include <arvgvstreamprivate.h>
33 #include <arvgvcp.h>
34 #include <arvgvsp.h>
35 #include <arvzip.h>
36 #include <arvstr.h>
37 #include <arvmisc.h>
38 #include <arvenumtypes.h>
39 #include <string.h>
40 #include <stdlib.h>
41 #ifdef __linux__
42 #include <linux/ip.h>
43 #endif
44 #ifdef BSD
45 #include <netinet/in.h>
46 #include <netinet/ip.h>
47 #define iphdr ip
48 #endif
49 #include <netinet/udp.h>
50
51 static GObjectClass *parent_class = NULL;
52
53 /* Shared data (main thread - heartbeat) */
54
55 #ifdef __APPLE__
56 struct iphdr
57 {
58 #if __BYTE_ORDER == __LITTLE_ENDIAN
59 unsigned int ihl:4;
60 unsigned int version:4;
61 #elif __BYTE_ORDER == __BIG_ENDIAN
62 unsigned int version:4;
63 unsigned int ihl:4;
64 #else
65 # error "Please fix <bits/endian.h>"
66 #endif
67 u_int8_t tos;
68 u_int16_t tot_len;
69 u_int16_t id;
70 u_int16_t frag_off;
71 u_int8_t ttl;
72 u_int8_t protocol;
73 u_int16_t check;
74 u_int32_t saddr;
75 u_int32_t daddr;
76 /*The options start here. */
77 };
78 #endif
79
80 typedef struct {
81 #if GLIB_CHECK_VERSION(2,32,0)
82 GMutex mutex;
83 #else
84 GMutex *mutex;
85 #endif
86
87 guint16 packet_id;
88
89 GSocket *socket;
90 GSocketAddress *interface_address;
91 GSocketAddress *device_address;
92
93 GPollFD poll_in_event;
94
95 void *buffer;
96
97 unsigned int gvcp_n_retries;
98 unsigned int gvcp_timeout_ms;
99
100 gboolean is_controller;
101 } ArvGvDeviceIOData;
102
103 struct _ArvGvDevicePrivate {
104 ArvGvDeviceIOData *io_data;
105
106 void *heartbeat_thread;
107 void *heartbeat_data;
108
109 ArvGc *genicam;
110
111 char *genicam_xml;
112 size_t genicam_xml_size;
113
114 gboolean is_packet_resend_supported;
115 gboolean is_write_memory_supported;
116
117 ArvGvStreamOption stream_options;
118 };
119
120 GRegex *
arv_gv_device_get_url_regex(void)121 arv_gv_device_get_url_regex (void)
122 {
123 static GRegex *arv_gv_device_url_regex = NULL;
124
125 if (arv_gv_device_url_regex == NULL)
126 arv_gv_device_url_regex = g_regex_new ("^(local:|file:|http:)(.+\\.[^;]+);?(?:0x)?([0-9:a-f]*)?;?(?:0x)?([0-9:a-f]*)?$",
127 G_REGEX_CASELESS, 0, NULL);
128
129 return arv_gv_device_url_regex;
130 }
131
132 static void
_flush_socket_buffer(ArvGvDeviceIOData * io_data)133 _flush_socket_buffer(ArvGvDeviceIOData *io_data)
134 {
135 GError *local_error = NULL;
136 gboolean success = TRUE;
137
138 while (success &&
139 g_poll (&io_data->poll_in_event, 1, 0) > 0
140 )
141 {
142 arv_debug_device ("[GvDevice::flush_receive_socket] Flush packet");
143 success = g_socket_receive (io_data->socket, io_data->buffer,
144 ARV_GV_DEVICE_BUFFER_SIZE, NULL, &local_error) > 0;
145 }
146 }
147
148 static gboolean
_read_memory(ArvGvDeviceIOData * io_data,guint64 address,guint32 size,void * buffer,GError ** error)149 _read_memory (ArvGvDeviceIOData *io_data, guint64 address, guint32 size, void *buffer, GError **error)
150 {
151 ArvGvcpPacket *packet;
152 ArvGvcpPacket *ack_packet = io_data->buffer;
153 size_t packet_size;
154 size_t answer_size;
155 int count;
156 unsigned int n_retries = 0;
157 gboolean success = FALSE;
158 guint32 timeout_ms;
159
160 answer_size = arv_gvcp_packet_get_read_memory_ack_size (size);
161
162 g_return_val_if_fail (answer_size <= ARV_GV_DEVICE_BUFFER_SIZE, FALSE);
163
164 #if GLIB_CHECK_VERSION(2,32,0)
165 g_mutex_lock (&io_data->mutex);
166 #else
167 g_mutex_lock (io_data->mutex);
168 #endif
169
170 packet = arv_gvcp_packet_new_read_memory_cmd (address,
171 ((size + sizeof (guint32) - 1)
172 / sizeof (guint32)) * sizeof (guint32),
173 0, &packet_size);
174
175 do {
176 GError *local_error = NULL;
177
178 io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id);
179 arv_gvcp_packet_set_packet_id (packet, io_data->packet_id);
180
181 arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
182
183 _flush_socket_buffer(io_data);
184 success = g_socket_send_to (io_data->socket, io_data->device_address,
185 (const char *) packet, packet_size,
186 NULL, &local_error) >= 0;
187
188 if (success) {
189 gboolean pending_ack;
190 gboolean expected_answer;
191
192 timeout_ms = io_data->gvcp_timeout_ms;
193
194 do {
195 success = TRUE;
196 success = success && g_poll (&io_data->poll_in_event, 1, timeout_ms) > 0;
197 if (success)
198 count = g_socket_receive (io_data->socket, io_data->buffer,
199 ARV_GV_DEVICE_BUFFER_SIZE, NULL, &local_error);
200 else
201 count = 0;
202 success = success && (count >= answer_size);
203
204 if (success) {
205 ArvGvcpPacketType packet_type;
206 ArvGvcpCommand command;
207 guint16 packet_id;
208
209 arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
210
211 packet_type = arv_gvcp_packet_get_packet_type (ack_packet);
212 command = arv_gvcp_packet_get_command (ack_packet);
213 packet_id = arv_gvcp_packet_get_packet_id (ack_packet);
214
215 if (command == ARV_GVCP_COMMAND_PENDING_ACK) {
216 pending_ack = TRUE;
217 expected_answer = FALSE;
218
219 timeout_ms = arv_gvcp_packet_get_pending_ack_timeout (ack_packet);
220
221 arv_log_device ("[GvDevice::read_memory] Pending ack timeout = %d", timeout_ms);
222 } else {
223 pending_ack = FALSE;
224 expected_answer = packet_type == ARV_GVCP_PACKET_TYPE_ACK &&
225 command == ARV_GVCP_COMMAND_READ_MEMORY_ACK &&
226 packet_id == io_data->packet_id;
227 if (!expected_answer) {
228 arv_debug_device ("[GvDevice::read_memory] Unexpected answer (0x%04x)",
229 packet_type);
230 }
231 }
232 } else {
233 pending_ack = FALSE;
234 expected_answer = FALSE;
235 if (local_error != NULL)
236 arv_warning_device ("[GvDevice::read_memory] Ack reception error: %s", local_error->message);
237 g_clear_error (&local_error);
238 }
239 } while (pending_ack);
240
241 success = success && expected_answer;
242
243 if (success)
244 memcpy (buffer, arv_gvcp_packet_get_read_memory_ack_data (ack_packet), size);
245 } else {
246 if (local_error != NULL)
247 arv_warning_device ("[GvDevice::read_memory] Command sending error: %s", local_error->message);
248 g_clear_error (&local_error);
249 }
250
251 n_retries++;
252 } while (!success && n_retries < io_data->gvcp_n_retries);
253
254 arv_gvcp_packet_free (packet);
255
256 #if GLIB_CHECK_VERSION(2,32,0)
257 g_mutex_unlock (&io_data->mutex);
258 #else
259 g_mutex_unlock (io_data->mutex);
260 #endif
261
262 if (!success) {
263 if (error != NULL && *error == NULL)
264 *error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
265 "[ArvDevice::read_memory] Timeout");
266 }
267
268 return success;
269 }
270
271 static gboolean
_write_memory(ArvGvDeviceIOData * io_data,guint64 address,guint32 size,void * buffer,GError ** error)272 _write_memory (ArvGvDeviceIOData *io_data, guint64 address, guint32 size, void *buffer, GError **error)
273 {
274 ArvGvcpPacket *packet;
275 ArvGvcpPacket *ack_packet = io_data->buffer;
276 size_t packet_size;
277 int count;
278 unsigned int n_retries = 0;
279 gboolean success = FALSE;
280 guint32 timeout_ms;
281
282 #if GLIB_CHECK_VERSION(2,32,0)
283 g_mutex_lock (&io_data->mutex);
284 #else
285 g_mutex_lock (io_data->mutex);
286 #endif
287
288 packet = arv_gvcp_packet_new_write_memory_cmd (address,
289 ((size + sizeof (guint32) - 1) /
290 sizeof (guint32)) * sizeof (guint32),
291 0, &packet_size);
292
293 memcpy (arv_gvcp_packet_get_write_memory_cmd_data (packet), buffer, size);
294
295 do {
296 GError *local_error = NULL;
297
298 io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id);
299 arv_gvcp_packet_set_packet_id (packet, io_data->packet_id);
300
301 arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
302
303 _flush_socket_buffer(io_data);
304 success = g_socket_send_to (io_data->socket, io_data->device_address,
305 (const char *) packet, packet_size,
306 NULL, &local_error) >= 0;
307
308 if (success) {
309 gboolean pending_ack;
310 gboolean expected_answer;
311
312 timeout_ms = io_data->gvcp_timeout_ms;
313
314 do {
315 success = TRUE;
316 success = success && g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0;
317 if (success)
318 count = g_socket_receive (io_data->socket, io_data->buffer,
319 ARV_GV_DEVICE_BUFFER_SIZE, NULL, &local_error);
320 else
321 count = 0;
322 success = success && (count >= arv_gvcp_packet_get_write_memory_ack_size ());
323
324 if (success) {
325 ArvGvcpPacketType packet_type;
326 ArvGvcpCommand command;
327 guint16 packet_id;
328
329 arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
330
331 packet_type = arv_gvcp_packet_get_packet_type (ack_packet);
332 command = arv_gvcp_packet_get_command (ack_packet);
333 packet_id = arv_gvcp_packet_get_packet_id (ack_packet);
334
335 if (command == ARV_GVCP_COMMAND_PENDING_ACK) {
336 pending_ack = TRUE;
337 expected_answer = FALSE;
338
339 timeout_ms = arv_gvcp_packet_get_pending_ack_timeout (ack_packet);
340
341 arv_log_device ("[GvDevice::write_memory] Pending ack timeout = %d", timeout_ms);
342 } else {
343 pending_ack = FALSE;
344 expected_answer = packet_type == ARV_GVCP_PACKET_TYPE_ACK &&
345 command == ARV_GVCP_COMMAND_WRITE_MEMORY_ACK &&
346 packet_id == io_data->packet_id;
347 if (!expected_answer) {
348 arv_debug_device ("[GvDevice::write_memory] Unexpected answer (0x%04x)",
349 packet_type);
350 }
351 }
352 } else {
353 pending_ack = FALSE;
354 expected_answer = FALSE;
355 if (local_error != NULL)
356 arv_warning_device ("[GvDevice::write_memory] Ack reception error: %s", local_error->message);
357 g_clear_error (&local_error);
358 }
359 } while (pending_ack);
360
361 success = success && expected_answer;
362 } else {
363 if (local_error != NULL)
364 arv_warning_device ("[GvDevice::write_memory] Command sending error: %s", local_error->message);
365 g_clear_error (&local_error);
366 }
367
368 n_retries++;
369
370 } while (!success && n_retries < io_data->gvcp_n_retries);
371
372 arv_gvcp_packet_free (packet);
373
374 #if GLIB_CHECK_VERSION(2,32,0)
375 g_mutex_unlock (&io_data->mutex);
376 #else
377 g_mutex_unlock (io_data->mutex);
378 #endif
379
380 if (!success) {
381 if (error != NULL && *error == NULL)
382 *error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
383 "[ArvDevice::write_memory] Timeout");
384 }
385
386 return success;
387 }
388
389 gboolean
_read_register(ArvGvDeviceIOData * io_data,guint32 address,guint32 * value_placeholder,GError ** error)390 _read_register (ArvGvDeviceIOData *io_data, guint32 address, guint32 *value_placeholder, GError **error)
391 {
392 ArvGvcpPacket *packet;
393 ArvGvcpPacket *ack_packet = io_data->buffer;
394 size_t packet_size;
395 int count;
396 unsigned int n_retries = 0;
397 gboolean success = FALSE;
398 guint32 timeout_ms;
399
400 #if GLIB_CHECK_VERSION(2,32,0)
401 g_mutex_lock (&io_data->mutex);
402 #else
403 g_mutex_lock (io_data->mutex);
404 #endif
405
406 packet = arv_gvcp_packet_new_read_register_cmd (address, 0, &packet_size);
407
408 do {
409 GError *local_error = NULL;
410
411 io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id);
412 arv_gvcp_packet_set_packet_id (packet, io_data->packet_id);
413
414 arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
415
416 _flush_socket_buffer(io_data);
417 success = g_socket_send_to (io_data->socket, io_data->device_address,
418 (const char *) packet, packet_size,
419 NULL, &local_error) >= 0;
420
421 if (success) {
422 gboolean pending_ack;
423 gboolean expected_answer;
424
425 timeout_ms = io_data->gvcp_timeout_ms;
426
427 do {
428 success = TRUE;
429 success = success && g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0;
430 if (success)
431 count = g_socket_receive (io_data->socket, io_data->buffer,
432 ARV_GV_DEVICE_BUFFER_SIZE, NULL, &local_error);
433 else
434 count = 0;
435 success = success && (count > 0);
436
437 if (success) {
438 ArvGvcpPacketType packet_type;
439 ArvGvcpCommand command;
440 guint16 packet_id;
441
442 arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
443
444 packet_type = arv_gvcp_packet_get_packet_type (ack_packet);
445 command = arv_gvcp_packet_get_command (ack_packet);
446 packet_id = arv_gvcp_packet_get_packet_id (ack_packet);
447
448 if (command == ARV_GVCP_COMMAND_PENDING_ACK) {
449 pending_ack = TRUE;
450 expected_answer = FALSE;
451
452 timeout_ms = arv_gvcp_packet_get_pending_ack_timeout (ack_packet);
453
454 arv_log_device ("[GvDevice::read_register] Pending ack timeout = %d", timeout_ms);
455 } else {
456 pending_ack = FALSE;
457 expected_answer = packet_type == ARV_GVCP_PACKET_TYPE_ACK &&
458 command == ARV_GVCP_COMMAND_READ_REGISTER_ACK &&
459 packet_id == io_data->packet_id;
460 if (!expected_answer) {
461 arv_debug_device ("[GvDevice::read_register] Unexpected answer (0x%04x)",
462 packet_type);
463 }
464 }
465 } else {
466 pending_ack = FALSE;
467 expected_answer = FALSE;
468 if (local_error != NULL)
469 arv_warning_device ("[GvDevice::read_register] Ack reception error: %s", local_error->message);
470 g_clear_error (&local_error);
471 }
472 } while (pending_ack);
473
474 success = success && expected_answer;
475
476 if (success)
477 *value_placeholder = arv_gvcp_packet_get_read_register_ack_value (ack_packet);
478 } else {
479 if (local_error != NULL)
480 arv_warning_device ("[GvDevice::read_register] Command sending error: %s", local_error->message);
481 g_clear_error (&local_error);
482 }
483
484 n_retries++;
485
486 } while (!success && n_retries < io_data->gvcp_n_retries);
487
488 arv_gvcp_packet_free (packet);
489
490 #if GLIB_CHECK_VERSION(2,32,0)
491 g_mutex_unlock (&io_data->mutex);
492 #else
493 g_mutex_unlock (io_data->mutex);
494 #endif
495
496 if (!success) {
497 *value_placeholder = 0;
498
499 if (error != NULL && *error == NULL)
500 *error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
501 "[ArvDevice::read_register] Timeout");
502 }
503
504 return success;
505 }
506
507 gboolean
_write_register(ArvGvDeviceIOData * io_data,guint32 address,guint32 value,GError ** error)508 _write_register (ArvGvDeviceIOData *io_data, guint32 address, guint32 value, GError **error)
509 {
510 ArvGvcpPacket *packet;
511 ArvGvcpPacket *ack_packet = io_data->buffer;
512 size_t packet_size;
513 int count;
514 unsigned int n_retries = 0;
515 gboolean success = FALSE;
516 guint32 timeout_ms;
517
518 #if GLIB_CHECK_VERSION(2,32,0)
519 g_mutex_lock (&io_data->mutex);
520 #else
521 g_mutex_lock (io_data->mutex);
522 #endif
523
524 packet = arv_gvcp_packet_new_write_register_cmd (address, value, io_data->packet_id, &packet_size);
525
526 do {
527 GError *local_error = NULL;
528
529 io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id);
530 arv_gvcp_packet_set_packet_id (packet, io_data->packet_id);
531
532 arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
533
534 _flush_socket_buffer(io_data);
535 success = g_socket_send_to (io_data->socket, io_data->device_address, (const char *) packet, packet_size,
536 NULL, &local_error) >= 0;
537
538 if (success) {
539 gboolean pending_ack;
540 gboolean expected_answer;
541
542 timeout_ms = io_data->gvcp_timeout_ms;
543
544 do {
545 success = TRUE;
546 success = success && g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0;
547 if (success)
548 count = g_socket_receive (io_data->socket, io_data->buffer,
549 ARV_GV_DEVICE_BUFFER_SIZE, NULL, NULL);
550 else
551 count = 0;
552 success = success && (count > 0);
553
554 if (success) {
555 ArvGvcpPacketType packet_type;
556 ArvGvcpCommand command;
557 guint16 packet_id;
558
559 arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
560
561 packet_type = arv_gvcp_packet_get_packet_type (ack_packet);
562 command = arv_gvcp_packet_get_command (ack_packet);
563 packet_id = arv_gvcp_packet_get_packet_id (ack_packet);
564
565 if (command == ARV_GVCP_COMMAND_PENDING_ACK) {
566 pending_ack = TRUE;
567 expected_answer = FALSE;
568
569 timeout_ms = arv_gvcp_packet_get_pending_ack_timeout (ack_packet);
570
571 arv_log_device ("[GvDevice::write_register] Pending ack timeout = %d", timeout_ms);
572 } else {
573 pending_ack = FALSE;
574 expected_answer = packet_type == ARV_GVCP_PACKET_TYPE_ACK &&
575 command == ARV_GVCP_COMMAND_WRITE_REGISTER_ACK &&
576 packet_id == io_data->packet_id;
577 if (!expected_answer) {
578 arv_debug_device ("[GvDevice::write_register] Unexpected answer (0x%04x)",
579 packet_type);
580 }
581 }
582 } else {
583 pending_ack = FALSE;
584 expected_answer = FALSE;
585 if (local_error != NULL)
586 arv_warning_device ("[GvDevice::write_register] Ack reception error: %s", local_error->message);
587 g_clear_error (&local_error);
588 }
589 } while (pending_ack);
590
591 success = success && expected_answer;
592 } else {
593 if (local_error != NULL)
594 arv_warning_device ("[GvDevice::write_register] Command sending error: %s", local_error->message);
595 g_clear_error (&local_error);
596 }
597
598 n_retries++;
599
600 } while (!success && n_retries < io_data->gvcp_n_retries);
601
602 arv_gvcp_packet_free (packet);
603
604 #if GLIB_CHECK_VERSION(2,32,0)
605 g_mutex_unlock (&io_data->mutex);
606 #else
607 g_mutex_unlock (io_data->mutex);
608 #endif
609
610 if (!success) {
611 if (error != NULL && *error == NULL)
612 *error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
613 "[ArvDevice::write_register] Timeout");
614 }
615
616 return success;
617 }
618
619 /* Heartbeat thread */
620
621 typedef struct {
622 ArvGvDevice *gv_device;
623 ArvGvDeviceIOData *io_data;
624 int period_us;
625 gboolean cancel;
626 } ArvGvDeviceHeartbeatData;
627
628 static void *
arv_gv_device_heartbeat_thread(void * data)629 arv_gv_device_heartbeat_thread (void *data)
630 {
631 ArvGvDeviceHeartbeatData *thread_data = data;
632 ArvGvDeviceIOData *io_data = thread_data->io_data;
633 GTimer *timer;
634 guint32 value;
635
636 timer = g_timer_new ();
637
638 do {
639 g_usleep (thread_data->period_us);
640
641 if (io_data->is_controller) {
642 guint counter = 1;
643
644 /* TODO: Instead of reading the control register, Pylon does write the heartbeat
645 * timeout value, which is interresting, as doing this we could get an error
646 * ack packet which will indicate we lost the control access. */
647
648 g_timer_start (timer);
649
650 while (!_read_register (io_data, ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET, &value, NULL) &&
651 g_timer_elapsed (timer, NULL) < ARV_GV_DEVICE_HEARTBEAT_RETRY_TIMEOUT_S &&
652 !g_atomic_int_get (&thread_data->cancel)) {
653 g_usleep (ARV_GV_DEVICE_HEARTBEAT_RETRY_DELAY_US);
654 counter++;
655 }
656
657 if (!g_atomic_int_get (&thread_data->cancel)) {
658 arv_log_device ("[GvDevice::Heartbeat] Ack value = %d", value);
659
660 if (counter > 1)
661 arv_log_device ("[GvDevice::Heartbeat] Tried %u times", counter);
662
663 if ((value & (ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_CONTROL |
664 ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_EXCLUSIVE)) == 0) {
665 arv_warning_device ("[GvDevice::Heartbeat] Control access lost");
666
667 arv_device_emit_control_lost_signal (ARV_DEVICE (thread_data->gv_device));
668
669 io_data->is_controller = FALSE;
670 }
671 } else
672 io_data->is_controller = FALSE;
673 }
674 } while (!g_atomic_int_get (&thread_data->cancel));
675
676 g_timer_destroy (timer);
677
678 return NULL;
679 }
680
681 /* ArvGvDevice implemenation */
682
683 static gboolean
arv_gv_device_take_control(ArvGvDevice * gv_device)684 arv_gv_device_take_control (ArvGvDevice *gv_device)
685 {
686 gboolean success;
687
688 success = arv_device_write_register (ARV_DEVICE (gv_device),
689 ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET,
690 ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_CONTROL, NULL);
691
692 gv_device->priv->io_data->is_controller = success;
693
694 /* Disable GVSP extended ID mode for now, it is not supported yet by ArvGvStream */
695 if (success)
696 arv_device_set_string_feature_value (ARV_DEVICE (gv_device), "GevGVSPExtendedIDMode", "Off");
697
698 if (!success)
699 arv_warning_device ("[GvDevice::take_control] Can't get control access");
700
701 return success;
702 }
703
704 static gboolean
arv_gv_device_leave_control(ArvGvDevice * gv_device)705 arv_gv_device_leave_control (ArvGvDevice *gv_device)
706 {
707 gboolean success;
708
709 gv_device->priv->io_data->is_controller = FALSE;
710
711 success = arv_device_write_register (ARV_DEVICE (gv_device),
712 ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET, 0, NULL);
713
714 return success;
715 }
716
717 guint64
arv_gv_device_get_timestamp_tick_frequency(ArvGvDevice * gv_device)718 arv_gv_device_get_timestamp_tick_frequency (ArvGvDevice *gv_device)
719 {
720 guint32 timestamp_tick_frequency_high;
721 guint32 timestamp_tick_frequency_low;
722
723 g_return_val_if_fail (ARV_IS_GV_DEVICE (gv_device), 0);
724
725 if (arv_device_read_register (ARV_DEVICE (gv_device),
726 ARV_GVBS_TIMESTAMP_TICK_FREQUENCY_HIGH_OFFSET,
727 ×tamp_tick_frequency_high, NULL) &&
728 arv_device_read_register (ARV_DEVICE (gv_device),
729 ARV_GVBS_TIMESTAMP_TICK_FREQUENCY_LOW_OFFSET,
730 ×tamp_tick_frequency_low, NULL)) {
731 guint64 timestamp_tick_frequency;
732
733 timestamp_tick_frequency = ((guint64) timestamp_tick_frequency_high << 32) |
734 timestamp_tick_frequency_low;
735 return timestamp_tick_frequency;
736 }
737
738 return 0;
739 }
740
741 guint
arv_gv_device_get_packet_size(ArvGvDevice * gv_device)742 arv_gv_device_get_packet_size (ArvGvDevice *gv_device)
743 {
744 return arv_device_get_integer_feature_value (ARV_DEVICE (gv_device), "GevSCPSPacketSize");
745 }
746
747 void
arv_gv_device_set_packet_size(ArvGvDevice * gv_device,gint packet_size)748 arv_gv_device_set_packet_size (ArvGvDevice *gv_device, gint packet_size)
749 {
750 g_return_if_fail (packet_size > 0);
751
752 arv_device_set_integer_feature_value (ARV_DEVICE (gv_device), "GevSCPSPacketSize", packet_size);
753 }
754
755 /**
756 * arv_gv_device_auto_packet_size:
757 * @gv_device: a #ArvGvDevice
758 *
759 * Automatically determine the biggest packet size that can be used data
760 * streaming, and set GevSCPSPacketSize value accordingly. This function relies
761 * on the GevSCPSFireTestPacket feature. If this feature is not available, the
762 * packet size will be set to a default value (1500 bytes).
763 *
764 * Returns: The packet size, in bytes.
765 *
766 * Since: 0.6.0
767 */
768
769 guint
arv_gv_device_auto_packet_size(ArvGvDevice * gv_device)770 arv_gv_device_auto_packet_size (ArvGvDevice *gv_device)
771 {
772 ArvDevice *device = ARV_DEVICE (gv_device);
773 ArvGvDeviceIOData *io_data = gv_device->priv->io_data;
774 ArvGcNode *node;
775 GSocket *socket;
776 GInetAddress *interface_address;
777 GSocketAddress *interface_socket_address;
778 GInetSocketAddress *local_address;
779 GPollFD poll_fd;
780 const guint8 *address_bytes;
781 guint16 port;
782 gboolean do_not_fragment;
783 gboolean is_command;
784 int n_events;
785 guint max_size, min_size, current_size;
786 guint packet_size = 1500;
787 char *buffer;
788
789 g_return_val_if_fail (ARV_IS_GV_DEVICE (gv_device), 1500);
790
791 node = arv_device_get_feature (device, "GevSCPSFireTestPacket");
792 if (!ARV_IS_GC_COMMAND (node) && !ARV_IS_GC_BOOLEAN (node)) {
793 arv_debug_device ("[GvDevice::auto_packet_size] No GevSCPSFireTestPacket feature found, "
794 "use default packet size (%d bytes)",
795 packet_size);
796 return packet_size;
797 }
798
799 is_command = ARV_IS_GC_COMMAND (node);
800
801 interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->interface_address));
802 interface_socket_address = g_inet_socket_address_new (interface_address, 0);
803 socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL);
804 g_socket_bind (socket, interface_socket_address, FALSE, NULL);
805 local_address = G_INET_SOCKET_ADDRESS (g_socket_get_local_address (socket, NULL));
806 port = g_inet_socket_address_get_port (local_address);
807
808 address_bytes = g_inet_address_to_bytes (interface_address);
809 arv_device_set_integer_feature_value (ARV_DEVICE (gv_device), "GevSCDA", g_htonl (*((guint32 *) address_bytes)));
810 arv_device_set_integer_feature_value (ARV_DEVICE (gv_device), "GevSCPHostPort", port);
811
812 g_clear_object (&local_address);
813 g_clear_object (&interface_socket_address);
814
815 do_not_fragment = arv_device_get_boolean_feature_value (device, "GevSCPSDoNotFragment");
816 arv_device_set_boolean_feature_value (device, "GevSCPSDoNotFragment", TRUE);
817
818 poll_fd.fd = g_socket_get_fd (socket);
819 poll_fd.events = G_IO_IN;
820 poll_fd.revents = 0;
821
822 current_size = 1500;
823 max_size = 16384;
824 min_size = 256;
825
826 buffer = g_malloc (8192);
827
828 do {
829 size_t read_count;
830 unsigned n_tries = 0;
831
832 arv_debug_device ("[GvDevice::auto_packet_size] Try packet size = %d", current_size);
833 arv_device_set_integer_feature_value (device, "GevSCPSPacketSize", current_size);
834
835 do {
836 if (is_command) {
837 arv_device_execute_command (device, "GevSCPSFireTestPacket");
838 } else {
839 arv_device_set_boolean_feature_value (device, "GevSCPSFireTestPacket", FALSE);
840 arv_device_set_boolean_feature_value (device, "GevSCPSFireTestPacket", TRUE);
841 }
842
843 do {
844 n_events = g_poll (&poll_fd, 1, 10);
845 if (n_events != 0)
846 read_count = g_socket_receive (socket, buffer, 8192, NULL, NULL);
847 else
848 read_count = 0;
849 /* Discard late packets, read_count should be equal to packet size minus IP and UDP headers */
850 } while (n_events != 0 && read_count != (current_size - sizeof (struct iphdr) - sizeof (struct udphdr)));
851
852 n_tries++;
853 } while (n_events == 0 && n_tries < 3);
854
855 if (n_events != 0) {
856 arv_debug_device ("[GvDevice::auto_packet_size] Received %d bytes", (int) read_count);
857
858 packet_size = current_size;
859 min_size = current_size;
860 current_size = (max_size - min_size) / 2 + min_size;
861 } else {
862 max_size = current_size;
863 current_size = (max_size - min_size) / 2 + min_size;
864 }
865 } while ((max_size - min_size) > 16);
866
867 g_clear_pointer (&buffer, g_free);
868 g_clear_object (&socket);
869
870 arv_debug_device ("[GvDevice::auto_packet_size] Packet size set to %d bytes", packet_size);
871
872 arv_device_set_boolean_feature_value (device, "GevSCPSDoNotFragment", do_not_fragment);
873 arv_device_set_integer_feature_value (device, "GevSCPSPacketSize", packet_size);
874
875 return packet_size;
876 }
877
878 static char *
_load_genicam(ArvGvDevice * gv_device,guint32 address,size_t * size)879 _load_genicam (ArvGvDevice *gv_device, guint32 address, size_t *size)
880 {
881 char filename[ARV_GVBS_XML_URL_SIZE];
882 char **tokens;
883 char *genicam = NULL;
884
885 g_return_val_if_fail (size != NULL, NULL);
886
887 *size = 0;
888
889 if (!arv_device_read_memory (ARV_DEVICE (gv_device), address, ARV_GVBS_XML_URL_SIZE, filename, NULL))
890 return NULL;
891
892 filename[ARV_GVBS_XML_URL_SIZE - 1] = '\0';
893
894 arv_debug_device ("[GvDevice::load_genicam] xml url = '%s' at 0x%x", filename, address);
895
896 tokens = g_regex_split (arv_gv_device_get_url_regex (), filename, 0);
897
898 if (tokens[0] != NULL && tokens[1] != NULL) {
899 if (g_ascii_strcasecmp (tokens[1], "file:") == 0) {
900 gsize len;
901 g_file_get_contents (tokens[2], &genicam, &len, NULL);
902 if (genicam)
903 *size = len;
904 } else if (g_ascii_strcasecmp (tokens[1], "local:") == 0 &&
905 tokens[2] != NULL &&
906 tokens[3] != NULL &&
907 tokens[4] != NULL) {
908 guint32 file_address;
909 guint32 file_size;
910
911 file_address = strtoul (tokens[3], NULL, 16);
912 file_size = strtoul (tokens[4], NULL, 16);
913
914 arv_debug_device ("[GvDevice::load_genicam] Xml address = 0x%x - size = 0x%x - %s",
915 file_address, file_size, tokens[2]);
916
917 if (file_size > 0) {
918 genicam = g_malloc (file_size);
919 if (arv_device_read_memory (ARV_DEVICE (gv_device), file_address, file_size,
920 genicam, NULL)) {
921
922 if (arv_debug_check (&arv_debug_category_misc, ARV_DEBUG_LEVEL_LOG)) {
923 GString *string = g_string_new ("");
924
925 g_string_append_printf (string,
926 "[GvDevice::load_genicam] Raw data size = 0x%x\n", file_size);
927 arv_g_string_append_hex_dump (string, genicam, file_size);
928
929 arv_log_misc ("%s", string->str);
930
931 g_string_free (string, TRUE);
932 }
933
934 if (g_str_has_suffix (tokens[2], ".zip")) {
935 ArvZip *zip;
936 const GSList *zip_files;
937
938 arv_debug_device ("[GvDevice::load_genicam] Zipped xml data");
939
940 zip = arv_zip_new (genicam, file_size);
941 zip_files = arv_zip_get_file_list (zip);
942
943 if (zip_files != NULL) {
944 const char *zip_filename;
945 void *tmp_buffer;
946 size_t tmp_buffer_size;
947
948 zip_filename = arv_zip_file_get_name (zip_files->data);
949 tmp_buffer = arv_zip_get_file (zip, zip_filename,
950 &tmp_buffer_size);
951
952 g_free (genicam);
953 file_size = tmp_buffer_size;
954 genicam = tmp_buffer;
955 } else
956 arv_warning_device ("[GvDevice::load_genicam] Invalid format");
957 arv_zip_free (zip);
958 }
959 *size = file_size;
960 } else {
961 g_free (genicam);
962 genicam = NULL;
963 *size = 0;
964 }
965 }
966 } else if (g_ascii_strcasecmp (tokens[1], "http:") == 0) {
967 GFile *file;
968 GFileInputStream *stream;
969
970 file = g_file_new_for_uri (filename);
971 stream = g_file_read (file, NULL, NULL);
972 if(stream) {
973 GDataInputStream *data_stream;
974 gsize len;
975
976 data_stream = g_data_input_stream_new (G_INPUT_STREAM (stream));
977 genicam = g_data_input_stream_read_upto (data_stream, "", 0, &len, NULL, NULL);
978
979 if (genicam)
980 *size = len;
981
982 g_object_unref (data_stream);
983 g_object_unref (stream);
984 }
985 g_object_unref (file);
986 }
987 }
988
989 g_strfreev (tokens);
990
991 return genicam;
992 }
993
994 static const char *
arv_gv_device_get_genicam_xml(ArvDevice * device,size_t * size)995 arv_gv_device_get_genicam_xml (ArvDevice *device, size_t *size)
996 {
997 char *xml;
998
999 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1000
1001 if (gv_device->priv->genicam_xml != NULL) {
1002 *size = gv_device->priv->genicam_xml_size;
1003 return gv_device->priv->genicam_xml;
1004 }
1005
1006 *size = 0;
1007
1008 xml = _load_genicam (gv_device, ARV_GVBS_XML_URL_0_OFFSET, size);
1009 if (xml == NULL)
1010 xml = _load_genicam (gv_device, ARV_GVBS_XML_URL_1_OFFSET, size);
1011
1012 gv_device->priv->genicam_xml = xml;
1013 gv_device->priv->genicam_xml_size = *size;
1014
1015 return xml;
1016 }
1017
1018 static void
arv_gv_device_load_genicam(ArvGvDevice * gv_device)1019 arv_gv_device_load_genicam (ArvGvDevice *gv_device)
1020 {
1021 const char *genicam;
1022 size_t size;
1023
1024 genicam = arv_gv_device_get_genicam_xml (ARV_DEVICE (gv_device), &size);
1025 if (genicam != NULL) {
1026 gv_device->priv->genicam = arv_gc_new (ARV_DEVICE (gv_device), genicam, size);
1027
1028 arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceVendorName",
1029 "<StringReg Name=\"DeviceVendorName\">"
1030 "<DisplayName>Vendor Name</DisplayName>"
1031 "<Address>0x48</Address>"
1032 "<Length>32</Length>"
1033 "<AccessMode>RO</AccessMode>"
1034 "<pPort>Device</pPort>"
1035 "</StringReg>");
1036 arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceModelName",
1037 "<StringReg Name=\"DeviceModelName\">"
1038 "<DisplayName>Model Name</DisplayName>"
1039 "<Address>0x68</Address>"
1040 "<Length>32</Length>"
1041 "<AccessMode>RO</AccessMode>"
1042 "<pPort>Device</pPort>"
1043 "</StringReg>");
1044 arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceVersion",
1045 "<StringReg Name=\"DeviceVersion\">"
1046 "<DisplayName>Device Version</DisplayName>"
1047 "<Address>0x88</Address>"
1048 "<Length>32</Length>"
1049 "<AccessMode>RO</AccessMode>"
1050 "<pPort>Device</pPort>"
1051 "</StringReg>");
1052 arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceManufacturerInfo",
1053 "<StringReg Name=\"DeviceManufacturerInfo\">"
1054 "<DisplayName>Manufacturer Info</DisplayName>"
1055 "<Address>0xa8</Address>"
1056 "<Length>48</Length>"
1057 "<AccessMode>RO</AccessMode>"
1058 "<pPort>Device</pPort>"
1059 "</StringReg>");
1060 arv_gc_set_default_node_data (gv_device->priv->genicam, "DeviceID",
1061 "<StringReg Name=\"DeviceID\">"
1062 "<DisplayName>Device ID</DisplayName>"
1063 "<Address>0xd8</Address>"
1064 "<Length>16</Length>"
1065 "<AccessMode>RO</AccessMode>"
1066 "<pPort>Device</pPort>"
1067 "</StringReg>");
1068 arv_gc_set_default_node_data (gv_device->priv->genicam, "NumberOfStreamChannels",
1069 "<IntReg Name=\"NumberOfStreamChannels\">"
1070 "<Address>0x904</Address>"
1071 "<Length>4</Length>"
1072 "<AccessMode>RO</AccessMode>"
1073 "<Endianess>BigEndian</Endianess>"
1074 "<pPort>Device</pPort>"
1075 "</IntReg>");
1076 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPHostPort",
1077 "<Integer Name=\"GevSCPHostPort\">"
1078 "<Visibility>Expert</Visibility>"
1079 "<pIsLocked>TLParamsLocked</pIsLocked>"
1080 "<pValue>GevSCPHostPortReg</pValue>"
1081 "</Integer>");
1082 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPHostPortReg",
1083 "<MaskedIntReg Name=\"GevSCPHostPortReg\">"
1084 "<Address>0xd00</Address>"
1085 "<pAddress>GevSCPAddrCalc</pAddress>"
1086 "<Length>4</Length>"
1087 "<AccessMode>RW</AccessMode>"
1088 "<pPort>Device</pPort>"
1089 "<LSB>31</LSB>"
1090 "<MSB>16</MSB>"
1091 "<Sign>Unsigned</Sign>"
1092 "<Endianess>BigEndian</Endianess>"
1093 "</MaskedIntReg>");
1094 #if 0
1095 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSFireTestPacket",
1096 "<Command Name=\"GevSCPSFireTestPacket\">"
1097 "<pIsLocked>TLParamsLocked</pIsLocked>"
1098 "<pValue>GevSCPSFireTestPacketReg</pValue>"
1099 "<CommandValue>1</CommandValue>"
1100 "</Boolean>");
1101 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSFireTestPacketReg",
1102 "<MaskedIntReg Name=\"GevSCPSFireTestPacketReg\">"
1103 "<Address>0x0d04</Address>"
1104 "<pAddress>GevSCPAddrCalc</pAddress>"
1105 "<Length>4</Length>"
1106 "<AccessMode>RW</AccessMode>"
1107 "<Bit>0</Bit>"
1108 "</MaskedIntReg>");
1109 #endif
1110 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSDoNotFragment",
1111 "<Boolean Name=\"GevSCPSDoNotFragment\">"
1112 "<pIsLocked>TLParamsLocked</pIsLocked>"
1113 "<pValue>GevSCPSDoNotFragmentReg</pValue>"
1114 "</Boolean>");
1115 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSDoNotFragmentReg",
1116 "<MaskedIntReg Name=\"GevSCPSDoNotFragmentReg\">"
1117 "<Address>0x0d04</Address>"
1118 "<pAddress>GevSCPAddrCalc</pAddress>"
1119 "<Length>4</Length>"
1120 "<AccessMode>RW</AccessMode>"
1121 "<Bit>1</Bit>"
1122 "</MaskedIntReg>");
1123 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSBigEndian",
1124 "<Boolean Name=\"GevSCPSBigEndian\">"
1125 "<pIsLocked>TLParamsLocked</pIsLocked>"
1126 "<pValue>GevSCPSBigEndianReg</pValue>"
1127 "</Boolean>");
1128 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSBigEndianReg",
1129 "<MaskedIntReg Name=\"GevSCPSBigEndianReg\">"
1130 "<Address>0x0d04</Address>"
1131 "<pAddress>GevSCPAddrCalc</pAddress>"
1132 "<Length>4</Length>"
1133 "<AccessMode>RW</AccessMode>"
1134 "<Bit>2</Bit>"
1135 "</MaskedIntReg>");
1136 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSPacketSize",
1137 "<Integer Name=\"GevSCPSPacketSize\">"
1138 "<Visibility>Expert</Visibility>"
1139 "<pIsLocked>TLParamsLocked</pIsLocked>"
1140 "<pValue>GevSCPSPacketSizeReg</pValue>"
1141 "</Integer>");
1142 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPSPacketSizeReg",
1143 "<MaskedIntReg Name=\"GevSCPSPacketSizeReg\">"
1144 "<Address>0xd04</Address>"
1145 "<pAddress>GevSCPAddrCalc</pAddress>"
1146 "<Length>4</Length>"
1147 "<AccessMode>RW</AccessMode>"
1148 "<pPort>Device</pPort>"
1149 "<LSB>31</LSB>"
1150 "<MSB>16</MSB>"
1151 "<Sign>Unsigned</Sign>"
1152 "<Endianess>BigEndian</Endianess>"
1153 "</MaskedIntReg>");
1154 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCDA",
1155 "<Integer Name=\"GevSCDA\">"
1156 "<Visibility>Expert</Visibility>"
1157 "<pIsLocked>TLParamsLocked</pIsLocked>"
1158 "<pValue>GevSCDAReg</pValue>"
1159 "</Integer>");
1160 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCDAReg",
1161 "<IntReg Name=\"GevSCDAReg\">"
1162 "<Address>0xd18</Address>"
1163 "<pAddress>GevSCPAddrCalc</pAddress>"
1164 "<Length>4</Length>"
1165 "<AccessMode>RW</AccessMode>"
1166 "<pPort>Device</pPort>"
1167 "<Sign>Unsigned</Sign>"
1168 "<Endianess>BigEndian</Endianess>"
1169 "</IntReg>");
1170 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCSP",
1171 "<Integer Name=\"GevSCSP\">"
1172 "<Visibility>Expert</Visibility>"
1173 "<pIsLocked>TLParamsLocked</pIsLocked>"
1174 "<pValue>GevSCSPReg</pValue>"
1175 "</Integer>");
1176 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCSPReg",
1177 "<MaskedIntReg Name=\"GevSCSPReg\">"
1178 "<Address>0xd1c</Address>"
1179 "<pAddress>GevSCPAddrCalc</pAddress>"
1180 "<Length>4</Length>"
1181 "<AccessMode>RO</AccessMode>"
1182 "<pPort>Device</pPort>"
1183 "<LSB>31</LSB>"
1184 "<MSB>16</MSB>"
1185 "<Sign>Unsigned</Sign>"
1186 "<Endianess>BigEndian</Endianess>"
1187 "</MaskedIntReg>");
1188 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevSCPAddrCalc",
1189 "<IntSwissKnife Name= \"GevSCPAddrCalc\">"
1190 "<pVariable Name=\"SEL\">GevStreamChannelSelector</pVariable>"
1191 "<Formula>SEL * 0x40</Formula>"
1192 "</IntSwissKnife>");
1193 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevStreamChannelSelector",
1194 "<Integer Name=\"GevStreamChannelSelector\">"
1195 "<Value>0</Value>"
1196 "<Min>0</Min>"
1197 "<pMax>GevStreamChannelSelectorMax</pMax>"
1198 "<Inc>1</Inc>"
1199 "</Integer>");
1200 arv_gc_set_default_node_data (gv_device->priv->genicam, "GevStreamChannelSelectorMax",
1201 "<IntSwissKnife Name=\"GevStreamChannelSelectorMax\">"
1202 "<pVariable Name=\"N_STREAM_CHANNELS\">NumberOfStreamChannels</pVariable>"
1203 "<Formula>N_STREAM_CHANNELS - 1</Formula>"
1204 "</IntSwissKnife>");
1205 arv_gc_set_default_node_data (gv_device->priv->genicam, "TLParamsLocked",
1206 "<Integer Name=\"TLParamsLocked\">"
1207 "<Visibility>Invisible</Visibility>"
1208 "<Value>0</Value>"
1209 "<Min>0</Min>"
1210 "<Max>1</Max>"
1211 "</Integer>");
1212 }
1213 }
1214
1215 /* ArvDevice implemenation */
1216
1217 static ArvStream *
arv_gv_device_create_stream(ArvDevice * device,ArvStreamCallback callback,void * user_data)1218 arv_gv_device_create_stream (ArvDevice *device, ArvStreamCallback callback, void *user_data)
1219 {
1220 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1221 ArvGvDeviceIOData *io_data = gv_device->priv->io_data;
1222 ArvStream *stream;
1223 guint32 n_stream_channels;
1224 GInetAddress *interface_address;
1225 GInetAddress *device_address;
1226
1227 n_stream_channels = arv_device_get_integer_feature_value (device, "NumberOfStreamChannels");
1228 arv_debug_device ("[GvDevice::create_stream] Number of stream channels = %d", n_stream_channels);
1229
1230 if (n_stream_channels < 1)
1231 return NULL;
1232
1233 if (!io_data->is_controller) {
1234 arv_warning_device ("[GvDevice::create_stream] Can't create stream without control access");
1235 return NULL;
1236 }
1237
1238 interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->interface_address));
1239 device_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->device_address));
1240
1241 stream = arv_gv_stream_new (gv_device, interface_address, device_address, callback, user_data);
1242 if (!ARV_IS_STREAM (stream))
1243 return NULL;
1244
1245 if (!gv_device->priv->is_packet_resend_supported)
1246 g_object_set (stream, "packet-resend", ARV_GV_STREAM_PACKET_RESEND_NEVER, NULL);
1247
1248 return stream;
1249 }
1250
1251 static ArvGc *
arv_gv_device_get_genicam(ArvDevice * device)1252 arv_gv_device_get_genicam (ArvDevice *device)
1253 {
1254 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1255
1256 return gv_device->priv->genicam;
1257 }
1258
1259 static gboolean
arv_gv_device_read_memory(ArvDevice * device,guint64 address,guint32 size,void * buffer,GError ** error)1260 arv_gv_device_read_memory (ArvDevice *device, guint64 address, guint32 size, void *buffer, GError **error)
1261 {
1262 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1263 int i;
1264 gint32 block_size;
1265
1266 for (i = 0; i < (size + ARV_GVCP_DATA_SIZE_MAX - 1) / ARV_GVCP_DATA_SIZE_MAX; i++) {
1267 block_size = MIN (ARV_GVCP_DATA_SIZE_MAX, size - i * ARV_GVCP_DATA_SIZE_MAX);
1268 if (!_read_memory (gv_device->priv->io_data,
1269 address + i * ARV_GVCP_DATA_SIZE_MAX,
1270 block_size, ((char *) buffer) + i * ARV_GVCP_DATA_SIZE_MAX, error))
1271 return FALSE;
1272 }
1273
1274 return TRUE;
1275 }
1276
1277 static gboolean
arv_gv_device_write_memory(ArvDevice * device,guint64 address,guint32 size,void * buffer,GError ** error)1278 arv_gv_device_write_memory (ArvDevice *device, guint64 address, guint32 size, void *buffer, GError **error)
1279 {
1280 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1281 int i;
1282 gint32 block_size;
1283
1284 for (i = 0; i < (size + ARV_GVCP_DATA_SIZE_MAX - 1) / ARV_GVCP_DATA_SIZE_MAX; i++) {
1285 block_size = MIN (ARV_GVCP_DATA_SIZE_MAX, size - i * ARV_GVCP_DATA_SIZE_MAX);
1286 if (!_write_memory (gv_device->priv->io_data,
1287 address + i * ARV_GVCP_DATA_SIZE_MAX,
1288 block_size, ((char *) buffer) + i * ARV_GVCP_DATA_SIZE_MAX, error))
1289 return FALSE;
1290 }
1291
1292 return TRUE;
1293 }
1294
1295 static gboolean
arv_gv_device_read_register(ArvDevice * device,guint64 address,guint32 * value,GError ** error)1296 arv_gv_device_read_register (ArvDevice *device, guint64 address, guint32 *value, GError **error)
1297 {
1298 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1299
1300 return _read_register (gv_device->priv->io_data, address, value, error);
1301 }
1302
1303 static gboolean
arv_gv_device_write_register(ArvDevice * device,guint64 address,guint32 value,GError ** error)1304 arv_gv_device_write_register (ArvDevice *device, guint64 address, guint32 value, GError **error)
1305 {
1306 ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
1307
1308 return _write_register (gv_device->priv->io_data, address, value, error);
1309 }
1310
1311 /**
1312 * arv_gv_device_get_stream_options:
1313 * @gv_device: a #ArvGvDevice
1314 *
1315 * Returns: options for stream creation
1316 *
1317 * Since: 0.6.0
1318 */
1319
1320 ArvGvStreamOption
arv_gv_device_get_stream_options(ArvGvDevice * gv_device)1321 arv_gv_device_get_stream_options (ArvGvDevice *gv_device)
1322 {
1323 g_return_val_if_fail (ARV_IS_GV_DEVICE (gv_device), ARV_GV_STREAM_OPTION_NONE);
1324
1325 return gv_device->priv->stream_options;
1326 }
1327
1328 /**
1329 * arv_gv_device_set_stream_options:
1330 * @gv_device: a #ArvGvDevice
1331 * @options: options for stream creation
1332 *
1333 * Sets the option used during stream creation. It must be called before arv_device_create_stream().
1334 *
1335 * Since: 0.6.0
1336 */
1337
1338 void
arv_gv_device_set_stream_options(ArvGvDevice * gv_device,ArvGvStreamOption options)1339 arv_gv_device_set_stream_options (ArvGvDevice *gv_device, ArvGvStreamOption options)
1340 {
1341 g_return_if_fail (ARV_IS_GV_DEVICE (gv_device));
1342
1343 gv_device->priv->stream_options = options;
1344 }
1345
1346 ArvDevice *
arv_gv_device_new(GInetAddress * interface_address,GInetAddress * device_address)1347 arv_gv_device_new (GInetAddress *interface_address, GInetAddress *device_address)
1348 {
1349 ArvGvDevice *gv_device;
1350 ArvGvDeviceIOData *io_data;
1351 ArvGvDeviceHeartbeatData *heartbeat_data;
1352 ArvGcRegisterDescriptionNode *register_description;
1353 ArvDomDocument *document;
1354 char *address_string;
1355 guint32 capabilities;
1356
1357 g_return_val_if_fail (G_IS_INET_ADDRESS (interface_address), NULL);
1358 g_return_val_if_fail (G_IS_INET_ADDRESS (device_address), NULL);
1359
1360 address_string = g_inet_address_to_string (interface_address);
1361 arv_debug_device ("[GvDevice::new] Interface address = %s", address_string);
1362 g_free (address_string);
1363 address_string = g_inet_address_to_string (device_address);
1364 arv_debug_device ("[GvDevice::new] Device address = %s", address_string);
1365 g_free (address_string);
1366
1367 gv_device = g_object_new (ARV_TYPE_GV_DEVICE, NULL);
1368
1369 io_data = g_new0 (ArvGvDeviceIOData, 1);
1370
1371 #if GLIB_CHECK_VERSION(2,32,0)
1372 g_mutex_init (&io_data->mutex);
1373 #else
1374 io_data->mutex = g_mutex_new ();
1375 #endif
1376 io_data->packet_id = 65300; /* Start near the end of the circular counter */
1377
1378 io_data->interface_address = g_inet_socket_address_new (interface_address, 0);
1379 io_data->device_address = g_inet_socket_address_new (device_address, ARV_GVCP_PORT);
1380 io_data->socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
1381 G_SOCKET_TYPE_DATAGRAM,
1382 G_SOCKET_PROTOCOL_UDP, NULL);
1383 g_socket_bind (io_data->socket, io_data->interface_address, FALSE, NULL);
1384
1385 io_data->buffer = g_malloc (ARV_GV_DEVICE_BUFFER_SIZE);
1386 io_data->gvcp_n_retries = ARV_GV_DEVICE_GVCP_N_RETRIES_DEFAULT;
1387 io_data->gvcp_timeout_ms = ARV_GV_DEVICE_GVCP_TIMEOUT_MS_DEFAULT;
1388 io_data->poll_in_event.fd = g_socket_get_fd (io_data->socket);
1389 io_data->poll_in_event.events = G_IO_IN;
1390 io_data->poll_in_event.revents = 0;
1391
1392 gv_device->priv->io_data = io_data;
1393
1394 arv_gv_device_load_genicam (gv_device);
1395
1396 if (!ARV_IS_GC (gv_device->priv->genicam)) {
1397 arv_warning_device ("[GvDevice::new] Failed to load genicam data");
1398 g_object_unref (gv_device);
1399 return NULL;
1400 }
1401
1402 arv_gv_device_take_control (gv_device);
1403
1404 heartbeat_data = g_new (ArvGvDeviceHeartbeatData, 1);
1405 heartbeat_data->gv_device = gv_device;
1406 heartbeat_data->io_data = io_data;
1407 heartbeat_data->period_us = ARV_GV_DEVICE_HEARTBEAT_PERIOD_US;
1408 heartbeat_data->cancel = FALSE;
1409
1410 gv_device->priv->heartbeat_data = heartbeat_data;
1411
1412 gv_device->priv->heartbeat_thread = arv_g_thread_new ("arv_gv_heartbeat", arv_gv_device_heartbeat_thread,
1413 gv_device->priv->heartbeat_data);
1414
1415 arv_device_read_register (ARV_DEVICE (gv_device), ARV_GVBS_GVCP_CAPABILITY_OFFSET, &capabilities, NULL);
1416 gv_device->priv->is_packet_resend_supported = (capabilities & ARV_GVBS_GVCP_CAPABILITY_PACKET_RESEND) != 0;
1417 gv_device->priv->is_write_memory_supported = (capabilities & ARV_GVBS_GVCP_CAPABILITY_WRITE_MEMORY) != 0;
1418
1419 arv_debug_device ("[GvDevice::new] Packet resend = %s", gv_device->priv->is_packet_resend_supported ? "yes" : "no");
1420 arv_debug_device ("[GvDevice::new] Write memory = %s", gv_device->priv->is_write_memory_supported ? "yes" : "no");
1421
1422 document = ARV_DOM_DOCUMENT (gv_device->priv->genicam);
1423 register_description = ARV_GC_REGISTER_DESCRIPTION_NODE (arv_dom_document_get_document_element (document));
1424 if (arv_gc_register_description_node_compare_schema_version (register_description, 1, 1, 0) < 0)
1425 arv_debug_device ("[GvDevice::new] Register workaround = yes");
1426
1427 return ARV_DEVICE (gv_device);
1428 }
1429
1430 static void
arv_gv_device_init(ArvGvDevice * gv_device)1431 arv_gv_device_init (ArvGvDevice *gv_device)
1432 {
1433 gv_device->priv = G_TYPE_INSTANCE_GET_PRIVATE (gv_device, ARV_TYPE_GV_DEVICE, ArvGvDevicePrivate);
1434
1435 gv_device->priv->genicam = NULL;
1436 gv_device->priv->genicam_xml = NULL;
1437 gv_device->priv->genicam_xml_size = 0;
1438 gv_device->priv->stream_options = ARV_GV_STREAM_OPTION_NONE;
1439 }
1440
1441 static void
arv_gv_device_finalize(GObject * object)1442 arv_gv_device_finalize (GObject *object)
1443 {
1444 ArvGvDevice *gv_device = ARV_GV_DEVICE (object);
1445 ArvGvDeviceIOData *io_data;
1446
1447 if (gv_device->priv->heartbeat_thread != NULL) {
1448 ArvGvDeviceHeartbeatData *heartbeat_data;
1449
1450 heartbeat_data = gv_device->priv->heartbeat_data;
1451
1452 g_atomic_int_set (&heartbeat_data->cancel, TRUE);
1453 g_thread_join (gv_device->priv->heartbeat_thread);
1454 g_free (heartbeat_data);
1455
1456 gv_device->priv->heartbeat_data = NULL;
1457 gv_device->priv->heartbeat_thread = NULL;
1458 }
1459
1460 arv_gv_device_leave_control (gv_device);
1461
1462 io_data = gv_device->priv->io_data;
1463 g_object_unref (io_data->device_address);
1464 g_object_unref (io_data->interface_address);
1465 g_object_unref (io_data->socket);
1466 g_free (io_data->buffer);
1467 #if GLIB_CHECK_VERSION(2,32,0)
1468 g_mutex_clear (&io_data->mutex);
1469 #else
1470 g_mutex_free (io_data->mutex);
1471 #endif
1472
1473 g_free (gv_device->priv->io_data);
1474
1475 if (gv_device->priv->genicam != NULL)
1476 g_object_unref (gv_device->priv->genicam);
1477
1478 g_free (gv_device->priv->genicam_xml);
1479
1480 parent_class->finalize (object);
1481 }
1482
1483 /**
1484 * arv_gv_device_get_interface_address:
1485 * @device: a #ArvGvDevice
1486 *
1487 * Returns: (transfer none): the device host interface IP address.
1488 *
1489 * Since: 0.2.0
1490 */
1491
arv_gv_device_get_interface_address(ArvGvDevice * device)1492 GSocketAddress *arv_gv_device_get_interface_address(ArvGvDevice *device)
1493 {
1494 ArvGvDeviceIOData *io_data = device->priv->io_data;
1495
1496 return io_data->interface_address;
1497 }
1498
1499 /**
1500 * arv_gv_device_get_device_address:
1501 * @device: a #ArvGvDevice
1502 *
1503 * Returns: (transfer none): the device IP address.
1504 *
1505 * since: 0.2.0
1506 */
1507
arv_gv_device_get_device_address(ArvGvDevice * device)1508 GSocketAddress *arv_gv_device_get_device_address(ArvGvDevice *device)
1509 {
1510 ArvGvDeviceIOData *io_data = device->priv->io_data;
1511
1512 return io_data->device_address;
1513 }
1514
1515 static void
arv_gv_device_class_init(ArvGvDeviceClass * gv_device_class)1516 arv_gv_device_class_init (ArvGvDeviceClass *gv_device_class)
1517 {
1518 GObjectClass *object_class = G_OBJECT_CLASS (gv_device_class);
1519 ArvDeviceClass *device_class = ARV_DEVICE_CLASS (gv_device_class);
1520
1521 g_type_class_add_private (gv_device_class, sizeof (ArvGvDevicePrivate));
1522
1523 parent_class = g_type_class_peek_parent (gv_device_class);
1524
1525 object_class->finalize = arv_gv_device_finalize;
1526
1527 device_class->create_stream = arv_gv_device_create_stream;
1528 device_class->get_genicam_xml = arv_gv_device_get_genicam_xml;
1529 device_class->get_genicam = arv_gv_device_get_genicam;
1530 device_class->read_memory = arv_gv_device_read_memory;
1531 device_class->write_memory = arv_gv_device_write_memory;
1532 device_class->read_register = arv_gv_device_read_register;
1533 device_class->write_register = arv_gv_device_write_register;
1534 }
1535
1536 G_DEFINE_TYPE (ArvGvDevice, arv_gv_device, ARV_TYPE_DEVICE)
1537