All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
stream.cc
Go to the documentation of this file.
1 /*
2  * This file is part of the rc_genicam_api package.
3  *
4  * Copyright (c) 2017 Roboception GmbH
5  * All rights reserved
6  *
7  * Author: Heiko Hirschmueller
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright notice,
16  * this list of conditions and the following disclaimer in the documentation
17  * and/or other materials provided with the distribution.
18  *
19  * 3. Neither the name of the copyright holder nor the names of its contributors
20  * may be used to endorse or promote products derived from this software without
21  * specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33  * POSSIBILITY OF SUCH DAMAGE.
34  */
35 
36 #include "stream.h"
37 #include "config.h"
38 
39 #include "gentl_wrapper.h"
40 #include "exception.h"
41 #include "cport.h"
42 
43 #include <iostream>
44 #include <algorithm>
45 
46 #ifdef _WIN32
47 #undef min
48 #undef max
49 #endif
50 
51 namespace rcg
52 {
53 
54 Stream::Stream(const std::shared_ptr<Device> &_parent,
55  const std::shared_ptr<const GenTLWrapper> &_gentl, const char *_id) :
56  buffer(_gentl, this)
57 {
58  parent=_parent;
59  gentl=_gentl;
60  id=_id;
61 
62  n_open=0;
63  stream=0;
64  event=0;
65  bn=0;
66 }
67 
69 {
70  try
71  {
72  stopStreaming();
73  }
74  catch (...) // do not throw exceptions in destructor
75  { }
76 
77  try
78  {
79  if (stream != 0)
80  {
81  gentl->DSClose(stream);
82  }
83  }
84  catch (...) // do not throw exceptions in destructor
85  { }
86 }
87 
88 std::shared_ptr<Device> Stream::getParent() const
89 {
90  return parent;
91 }
92 
93 const std::string &Stream::getID() const
94 {
95  return id;
96 }
97 
99 {
100  std::lock_guard<std::recursive_mutex> lock(mtx);
101 
102  if (n_open == 0)
103  {
104  if (parent->getHandle() != 0)
105  {
106  if (gentl->DevOpenDataStream(parent->getHandle(), id.c_str(), &stream) !=
108  {
109  throw GenTLException("Stream::open()", gentl);
110  }
111  }
112  else
113  {
114  throw GenTLException("Stream::open(): Device must be opened before open before opening a stream");
115  }
116  }
117 
118  n_open++;
119 }
120 
122 {
123  std::lock_guard<std::recursive_mutex> lock(mtx);
124 
125  if (n_open > 0)
126  {
127  n_open--;
128 
129  if (n_open == 0)
130  {
131  try
132  {
133  stopStreaming();
134  }
135  catch (...)
136  {
137  gentl->DSClose(stream);
138  stream=0;
139 
140  buffer.setNodemap(0, "");
141 
142  nodemap=0;
143  cport=0;
144 
145  throw;
146  }
147  }
148  }
149 }
150 
151 void Stream::attachBuffers(bool enable)
152 {
153  if (enable)
154  {
155  if (parent->getHandle() != 0)
156  {
157  std::shared_ptr<GenApi::CNodeMapRef> rnodemap=parent->getRemoteNodeMap();
158  buffer.setNodemap(rnodemap, parent->getTLType());
159  }
160  }
161  else
162  {
163  buffer.setNodemap(0, "");
164  }
165 }
166 
167 void Stream::startStreaming(int nacquire)
168 {
169  startStreaming(nacquire, 4);
170 }
171 
172 void Stream::startStreaming(int nacquire, int min_buffers)
173 {
174  std::lock_guard<std::recursive_mutex> lock(mtx);
175 
176  buffer.setHandle(0);
177 
178  if (stream == 0)
179  {
180  throw GenTLException("Stream::startStreaming(): Stream is not open");
181  }
182 
183  // stop streaming if it is currently running
184 
185  if (bn > 0)
186  {
187  stopStreaming();
188  }
189 
190  // lock parameters before streaming starts
191 
192  std::shared_ptr<GenApi::CNodeMapRef> nmap=parent->getRemoteNodeMap();
193  GenApi::IInteger *p=dynamic_cast<GenApi::IInteger *>(nmap->_GetNode("TLParamsLocked"));
194 
195  if (GenApi::IsWritable(p))
196  {
197  p->SetValue(1);
198  }
199 
200  // determine maximum buffer size from transport layer or remote device
201 
202  size_t size=0;
203  if (getDefinesPayloadsize())
204  {
205  size=getPayloadSize();
206  }
207  else
208  {
209  GenApi::IInteger *pp=dynamic_cast<GenApi::IInteger *>(nmap->_GetNode("PayloadSize"));
210 
211  if (GenApi::IsReadable(pp))
212  {
213  size=static_cast<size_t>(pp->GetValue());
214  }
215  }
216 
217  // announce and queue the minimum number of buffers
218 
219  bool err=false;
220 
221  bn=std::max(static_cast<size_t>(min_buffers), getBufAnnounceMin());
222  for (size_t i=0; i<bn; i++)
223  {
225 
226  if (gentl->DSAllocAndAnnounceBuffer(stream, size, 0, &pp) != GenTL::GC_ERR_SUCCESS)
227  {
228  err=true;
229  break;
230  }
231 
232  if (!err && gentl->DSQueueBuffer(stream, pp) != GenTL::GC_ERR_SUCCESS)
233  {
234  err=true;
235  break;
236  }
237  }
238 
239  // register event
240 
241  if (!err && gentl->GCRegisterEvent(stream, GenTL::EVENT_NEW_BUFFER, &event) !=
243  {
244  err=true;
245  }
246 
247  // start streaming
248 
249  uint64_t n=GENTL_INFINITE;
250 
251  if (nacquire > 0)
252  {
253  n=static_cast<uint64_t>(nacquire);
254  }
255 
256  if (!err && gentl->DSStartAcquisition(stream, GenTL::ACQ_START_FLAGS_DEFAULT, n) !=
258  {
259  gentl->GCUnregisterEvent(stream, GenTL::EVENT_NEW_BUFFER);
260  err=true;
261  }
262 
263  if (!err)
264  {
265  GenApi::CCommandPtr start=parent->getRemoteNodeMap()->_GetNode("AcquisitionStart");
266  start->Execute();
267  }
268 
269  // revoke buffers in case of an error, before throwing an event
270 
271  if (err)
272  {
273  gentl->DSFlushQueue(stream, GenTL::ACQ_QUEUE_ALL_DISCARD);
274 
276  while (gentl->DSGetBufferID(stream, 0, &pp) == GenTL::GC_ERR_SUCCESS)
277  {
278  gentl->DSRevokeBuffer(stream, pp, 0, 0);
279  }
280 
281  // unlock parameters
282 
283  GenApi::IInteger *pi=dynamic_cast<GenApi::IInteger *>(nmap->_GetNode("TLParamsLocked"));
284 
285  if (GenApi::IsWritable(pi))
286  {
287  pi->SetValue(0);
288  }
289 
290  throw GenTLException("Stream::startStreaming()", gentl);
291  }
292 }
293 
295 {
296  std::lock_guard<std::recursive_mutex> lock(mtx);
297 
298  if (bn > 0)
299  {
300  buffer.setHandle(0);
301 
302  // do not throw exceptions as this method is also called in destructor
303 
304  GenApi::CCommandPtr stop=parent->getRemoteNodeMap()->_GetNode("AcquisitionStop");
305  stop->Execute();
306 
307  gentl->DSStopAcquisition(stream, GenTL::ACQ_STOP_FLAGS_DEFAULT);
308  gentl->GCUnregisterEvent(stream, GenTL::EVENT_NEW_BUFFER);
309  gentl->DSFlushQueue(stream, GenTL::ACQ_QUEUE_ALL_DISCARD);
310 
311  // free all buffers
312 
313  for (size_t i=0; i<bn; i++)
314  {
316  if (gentl->DSGetBufferID(stream, 0, &p) == GenTL::GC_ERR_SUCCESS)
317  {
318  gentl->DSRevokeBuffer(stream, p, 0, 0);
319  }
320  }
321 
322  event=0;
323  bn=0;
324 
325  // unlock parameters
326 
327  std::shared_ptr<GenApi::CNodeMapRef> nmap=parent->getRemoteNodeMap();
328  GenApi::IInteger *pi=dynamic_cast<GenApi::IInteger *>(nmap->_GetNode("TLParamsLocked"));
329 
330  if (GenApi::IsWritable(pi))
331  {
332  pi->SetValue(0);
333  }
334  }
335 }
336 
338 {
339  size_t ret=0;
340 
342  size_t size=sizeof(ret);
343 
344  if (bn > 0 && event != 0)
345  {
346  if (gentl->EventGetInfo(event, GenTL::EVENT_NUM_IN_QUEUE, &type, &ret, &size) != GenTL::GC_ERR_SUCCESS)
347  {
348  ret=0;
349  }
350  }
351 
352  return static_cast<int>(ret);
353 }
354 
355 const Buffer *Stream::grab(int64_t _timeout)
356 {
357  std::lock_guard<std::recursive_mutex> lock(mtx);
358 
359  uint64_t timeout=GENTL_INFINITE;
360  if (_timeout >= 0)
361  {
362  timeout=static_cast<uint64_t>(_timeout);
363  }
364 
365  // check that streaming had been started
366 
367  if (bn == 0 || event == 0)
368  {
369  throw GenTLException("Streaming::grab(): Streaming not started");
370  }
371 
372  // enqueue previously delivered buffer if any
373 
374  if (buffer.getHandle() != 0)
375  {
376  if (gentl->DSQueueBuffer(stream, buffer.getHandle()) != GenTL::GC_ERR_SUCCESS)
377  {
378  buffer.setHandle(0);
379  throw GenTLException("Stream::grab()", gentl);
380  }
381 
382  buffer.setHandle(0);
383  }
384 
385  // wait for event
386 
388  size_t size=sizeof(GenTL::EVENT_NEW_BUFFER_DATA);
389  memset(&data, 0, size);
390 
391  GenTL::GC_ERROR err=gentl->EventGetData(event, &data, &size, timeout);
392 
393  // return 0 in case of abort and timeout and throw exception in case of
394  // another error
395 
396  if (err == GenTL::GC_ERR_ABORT || err == GenTL::GC_ERR_TIMEOUT)
397  {
398  return 0;
399  }
400  else if (err != GenTL::GC_ERR_SUCCESS)
401  {
402  throw GenTLException("Stream::grab()", gentl);
403  }
404 
405  // return buffer
406 
407  buffer.setHandle(data.BufferHandle);
408 
409  return &buffer;
410 }
411 
412 namespace
413 {
414 
415 template<class T> inline T getStreamValue(const std::shared_ptr<const GenTLWrapper> &gentl,
416  void *stream, GenTL::STREAM_INFO_CMD cmd)
417 {
418  T ret=0;
419 
421  size_t size=sizeof(T);
422 
423  if (stream != 0)
424  {
425  gentl->DSGetInfo(stream, cmd, &type, &ret, &size);
426  }
427 
428  return ret;
429 }
430 
431 inline bool getStreamBool(const std::shared_ptr<const GenTLWrapper> &gentl,
432  void *stream, GenTL::STREAM_INFO_CMD cmd)
433 {
434  bool8_t ret=0;
435 
437  size_t size=sizeof(ret);
438 
439  if (stream != 0)
440  {
441  gentl->DSGetInfo(stream, cmd, &type, &ret, &size);
442  }
443 
444  return ret != 0;
445 }
446 
447 }
448 
450 {
451  std::lock_guard<std::recursive_mutex> lock(mtx);
452  return getStreamValue<uint64_t>(gentl, stream, GenTL::STREAM_INFO_NUM_DELIVERED);
453 }
454 
456 {
457  std::lock_guard<std::recursive_mutex> lock(mtx);
458  return getStreamValue<uint64_t>(gentl, stream, GenTL::STREAM_INFO_NUM_UNDERRUN);
459 }
460 
462 {
463  std::lock_guard<std::recursive_mutex> lock(mtx);
464  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_NUM_ANNOUNCED);
465 }
466 
468 {
469  std::lock_guard<std::recursive_mutex> lock(mtx);
470  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_NUM_QUEUED);
471 }
472 
474 {
475  std::lock_guard<std::recursive_mutex> lock(mtx);
476  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_NUM_AWAIT_DELIVERY);
477 }
478 
480 {
481  std::lock_guard<std::recursive_mutex> lock(mtx);
482  return getStreamValue<uint64_t>(gentl, stream, GenTL::STREAM_INFO_NUM_STARTED);
483 }
484 
486 {
487  std::lock_guard<std::recursive_mutex> lock(mtx);
488  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_PAYLOAD_SIZE);
489 }
490 
492 {
493  std::lock_guard<std::recursive_mutex> lock(mtx);
494  return getStreamBool(gentl, stream, GenTL::STREAM_INFO_IS_GRABBING);
495 }
496 
498 {
499  std::lock_guard<std::recursive_mutex> lock(mtx);
500  return getStreamBool(gentl, stream, GenTL::STREAM_INFO_DEFINES_PAYLOADSIZE);
501 }
502 
503 std::string Stream::getTLType()
504 {
505  std::lock_guard<std::recursive_mutex> lock(mtx);
506  std::string ret;
507 
509  char tmp[1024]="";
510  size_t size=sizeof(tmp);
511 
512  if (stream != 0)
513  {
514  if (gentl->DSGetInfo(stream, GenTL::STREAM_INFO_TLTYPE, &type, tmp, &size) ==
516  {
517  if (type == GenTL::INFO_DATATYPE_STRING)
518  {
519  ret=tmp;
520  }
521  }
522  }
523 
524  return ret;
525 }
526 
528 {
529  std::lock_guard<std::recursive_mutex> lock(mtx);
530  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_NUM_CHUNKS_MAX);
531 }
532 
534 {
535  std::lock_guard<std::recursive_mutex> lock(mtx);
536  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_BUF_ANNOUNCE_MIN);
537 }
538 
540 {
541  std::lock_guard<std::recursive_mutex> lock(mtx);
542  return getStreamValue<size_t>(gentl, stream, GenTL::STREAM_INFO_BUF_ALIGNMENT);
543 }
544 
545 std::shared_ptr<GenApi::CNodeMapRef> Stream::getNodeMap()
546 {
547  std::lock_guard<std::recursive_mutex> lock(mtx);
548  if (stream != 0 && !nodemap)
549  {
550  cport=std::shared_ptr<CPort>(new CPort(gentl, &stream));
552  }
553 
554  return nodemap;
555 }
556 
557 void *Stream::getHandle() const
558 {
559  return stream;
560 }
561 
562 }
GENAPI_NAMESPACE::IInteger
GENICAM_INTERFACE IInteger
Interface for integer properties.
Definition: IFloat.h:114
INFO_DATATYPE
int32_t INFO_DATATYPE
Definition: GenTL_v1_6.h:261
INFO_DATATYPE_STRING
@ INFO_DATATYPE_STRING
Definition: GenTL_v1_6.h:244
rcg::Stream::getNumAnnounced
size_t getNumAnnounced()
Returns some information about the stream.
Definition: stream.cc:461
GENAPI_NAMESPACE::IsWritable
bool IsWritable(EAccessMode AccessMode)
Tests if writable.
Definition: INode.h:196
rcg::Stream::stream
void * stream
Definition: stream.h:318
rcg::Stream::startStreaming
void startStreaming(int nacquire=-1)
Allocates four buffers, registers internal events and starts streaming of nacquire buffers.
Definition: stream.cc:167
rcg::Stream::getNumQueued
size_t getNumQueued()
Returns some information about the stream.
Definition: stream.cc:467
ACQ_STOP_FLAGS_DEFAULT
@ ACQ_STOP_FLAGS_DEFAULT
Definition: GenTL_v1_6.h:348
rcg::Buffer::setNodemap
void setNodemap(const std::shared_ptr< GenApi::CNodeMapRef > nodemap, const std::string &tltype)
Set the device nodemap.
Definition: buffer.cc:146
EVENT_NEW_BUFFER
@ EVENT_NEW_BUFFER
Definition: GenTL_v1_6.h:582
rcg::Stream::event
void * event
Definition: stream.h:319
rcg::Buffer
The buffer class encapsulates a Genicam buffer that is provided by a stream.
Definition: buffer.h:118
STREAM_INFO_IS_GRABBING
@ STREAM_INFO_IS_GRABBING
Definition: GenTL_v1_6.h:388
GENTL_INFINITE
#define GENTL_INFINITE
Definition: GenTL_v1_6.h:238
rcg::Buffer::setHandle
void setHandle(void *handle)
Set the buffer handle that this object should manage.
Definition: buffer.cc:171
rcg::Stream::close
void close()
Closes the stream.
Definition: stream.cc:121
rcg::Buffer::getHandle
void * getHandle() const
Get internal stream handle.
Definition: buffer.cc:717
rcg::Stream::getNumStarted
uint64_t getNumStarted()
Returns some information about the stream.
Definition: stream.cc:479
STREAM_INFO_BUF_ANNOUNCE_MIN
@ STREAM_INFO_BUF_ANNOUNCE_MIN
Definition: GenTL_v1_6.h:392
rcg::Stream::attachBuffers
void attachBuffers(bool enable)
Enabling or disabling attaching the grabbed buffer to the remote device nodemap.
Definition: stream.cc:151
GC_ERROR
int32_t GC_ERROR
Definition: GenTL_v1_6.h:185
rcg::Stream::getAvailableBufferCount
int getAvailableBufferCount()
Returns the number ob buffers that are currently available for grabbing.
Definition: stream.cc:337
rcg
Definition: buffer.cc:47
rcg::Stream::stopStreaming
void stopStreaming()
Stops streaming.
Definition: stream.cc:294
rcg::Stream::getNumChunksMax
size_t getNumChunksMax()
Returns some information about the stream.
Definition: stream.cc:527
STREAM_INFO_DEFINES_PAYLOADSIZE
@ STREAM_INFO_DEFINES_PAYLOADSIZE
Definition: GenTL_v1_6.h:389
STREAM_INFO_NUM_DELIVERED
@ STREAM_INFO_NUM_DELIVERED
Definition: GenTL_v1_6.h:381
rcg::Stream::getHandle
void * getHandle() const
Get internal stream handle.
Definition: stream.cc:557
rcg::Stream::mtx
std::recursive_mutex mtx
Definition: stream.h:315
rcg::CPort
This is the port definition that connects GenAPI to GenTL.
Definition: cport.h:52
rcg::Stream::bn
size_t bn
Definition: stream.h:320
GC_ERR_SUCCESS
@ GC_ERR_SUCCESS
Definition: GenTL_v1_6.h:158
rcg::Stream::getNodeMap
std::shared_ptr< GenApi::CNodeMapRef > getNodeMap()
Returns the node map of this object.
Definition: stream.cc:545
STREAM_INFO_NUM_STARTED
@ STREAM_INFO_NUM_STARTED
Definition: GenTL_v1_6.h:386
ACQ_START_FLAGS_DEFAULT
@ ACQ_START_FLAGS_DEFAULT
Definition: GenTL_v1_6.h:358
STREAM_INFO_CMD
int32_t STREAM_INFO_CMD
Definition: GenTL_v1_6.h:399
rcg::allocNodeMap
std::shared_ptr< GenApi::CNodeMapRef > allocNodeMap(std::shared_ptr< const GenTLWrapper > gentl, void *port, CPort *cport, const char *xml)
Convenience function that returns a GenICam node map from the given port.
Definition: cport.cc:156
STREAM_INFO_BUF_ALIGNMENT
@ STREAM_INFO_BUF_ALIGNMENT
Definition: GenTL_v1_6.h:393
STREAM_INFO_NUM_UNDERRUN
@ STREAM_INFO_NUM_UNDERRUN
Definition: GenTL_v1_6.h:382
bool8_t
uint8_t bool8_t
Definition: GenTL_v1_6.h:108
stream.h
STREAM_INFO_PAYLOAD_SIZE
@ STREAM_INFO_PAYLOAD_SIZE
Definition: GenTL_v1_6.h:387
STREAM_INFO_NUM_CHUNKS_MAX
@ STREAM_INFO_NUM_CHUNKS_MAX
Definition: GenTL_v1_6.h:391
rcg::Stream::getDefinesPayloadsize
bool getDefinesPayloadsize()
Returns some information about the stream.
Definition: stream.cc:497
rcg::Stream::getParent
std::shared_ptr< Device > getParent() const
Returns the pointer to the parent device object.
Definition: stream.cc:88
rcg::Stream::getBufAlignment
size_t getBufAlignment()
Returns some information about the stream.
Definition: stream.cc:539
GENAPI_NAMESPACE::IsReadable
bool IsReadable(EAccessMode AccessMode)
Tests if readable.
Definition: INode.h:178
rcg::Stream::id
std::string id
Definition: stream.h:313
STREAM_INFO_TLTYPE
@ STREAM_INFO_TLTYPE
Definition: GenTL_v1_6.h:390
rcg::Stream::getID
const std::string & getID() const
Get the internal ID of this stream.
Definition: stream.cc:93
rcg::Stream::getIsGrabbing
bool getIsGrabbing()
Returns some information about the stream.
Definition: stream.cc:491
STREAM_INFO_NUM_AWAIT_DELIVERY
@ STREAM_INFO_NUM_AWAIT_DELIVERY
Definition: GenTL_v1_6.h:385
rcg::Stream::Stream
Stream(const std::shared_ptr< Device > &parent, const std::shared_ptr< const GenTLWrapper > &gentl, const char *id)
Constructs a stream class.
Definition: stream.cc:54
rcg::Stream::open
void open()
Opens the stream for working with it.
Definition: stream.cc:98
EVENT_NUM_IN_QUEUE
@ EVENT_NUM_IN_QUEUE
Definition: GenTL_v1_6.h:596
config.h
GC_ERR_ABORT
@ GC_ERR_ABORT
Definition: GenTL_v1_6.h:170
GENAPI_NAMESPACE::CPointer
Encapsulates a GenApi pointer dealing with the dynamic_cast automatically.
Definition: Pointer.h:51
rcg::Stream::getBufAnnounceMin
size_t getBufAnnounceMin()
Returns some information about the stream.
Definition: stream.cc:533
STREAM_INFO_NUM_QUEUED
@ STREAM_INFO_NUM_QUEUED
Definition: GenTL_v1_6.h:384
rcg::Stream::grab
const Buffer * grab(int64_t timeout=-1)
Wait for the next image or data and return it in a buffer object.
Definition: stream.cc:355
STREAM_INFO_NUM_ANNOUNCED
@ STREAM_INFO_NUM_ANNOUNCED
Definition: GenTL_v1_6.h:383
rcg::Stream::cport
std::shared_ptr< CPort > cport
Definition: stream.h:322
int64_t
__int64 int64_t
Definition: config-win32.h:21
rcg::Stream::buffer
Buffer buffer
Definition: stream.h:309
EVENT_NEW_BUFFER_DATA
struct S_EVENT_NEW_BUFFER EVENT_NEW_BUFFER_DATA
rcg::Stream::getNumUnderrun
uint64_t getNumUnderrun()
Returns some information about the stream.
Definition: stream.cc:455
rcg::Stream::getTLType
std::string getTLType()
Returns some information about the stream.
Definition: stream.cc:503
cport.h
ACQ_QUEUE_ALL_DISCARD
@ ACQ_QUEUE_ALL_DISCARD
Definition: GenTL_v1_6.h:371
rcg::Stream::getNumDelivered
uint64_t getNumDelivered()
Returns some information about the stream.
Definition: stream.cc:449
rcg::Stream::parent
std::shared_ptr< Device > parent
Definition: stream.h:311
exception.h
rcg::Stream::nodemap
std::shared_ptr< GenApi::CNodeMapRef > nodemap
Definition: stream.h:323
rcg::Stream::getNumAwaitDelivery
size_t getNumAwaitDelivery()
Returns some information about the stream.
Definition: stream.cc:473
rcg::Stream::gentl
std::shared_ptr< const GenTLWrapper > gentl
Definition: stream.h:312
rcg::Stream::n_open
int n_open
Definition: stream.h:317
rcg::Stream::~Stream
~Stream()
Definition: stream.cc:68
BUFFER_HANDLE
void * BUFFER_HANDLE
Definition: GenTL_v1_6.h:231
GC_ERR_TIMEOUT
@ GC_ERR_TIMEOUT
Definition: GenTL_v1_6.h:169
gentl_wrapper.h
rcg::GenTLException
Definition: exception.h:47
rcg::Stream::getPayloadSize
size_t getPayloadSize()
Returns some information about the stream.
Definition: stream.cc:485


rc_genicam_api
Author(s): Heiko Hirschmueller
autogenerated on Wed Dec 4 2024 03:10:12