VimbaC.h
Go to the documentation of this file.
1 /*=============================================================================
2  Copyright (C) 2012 Allied Vision Technologies. All Rights Reserved.
3 
4  Redistribution of this header file, in original or modified form, without
5  prior written consent of Allied Vision Technologies is prohibited.
6 
7 -------------------------------------------------------------------------------
8 
9  File: VimbaC.h
10 
11  Description: Main header file for the VimbaC API.
12 
13 -------------------------------------------------------------------------------
14 
15  THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
16  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE,
17  NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18  DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
19  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
23  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 
26 =============================================================================*/
27 
28 #ifndef VIMBAC_H_INCLUDE_
29 #define VIMBAC_H_INCLUDE_
30 
31 // This file describes all necessary definitions for using Allied Vision's
32 // VimbaC API. These type definitions are designed to be portable from other
33 // languages and other operating systems.
34 //
35 // General conventions:
36 // - Method names are composed in the following manner:
37 // - Vmb"Action" example: VmbStartup()
38 // - Vmb"Entity""Action" or Vmb"ActionTarget""Action" example: VmbInterfaceOpen()
39 // - Vmb"Entity""SubEntity/ActionTarget""Action" example: VmbFeatureCommandRun()
40 // - Methods dealing with features, memory or registers accept a handle from the following
41 // entity list as first parameter: System, Camera, Interface and AncillaryData.
42 // All other methods taking handles accept only a specific handle.
43 // - Strings (generally declared as "const char *") are assumed to have a trailing 0 character
44 // - All pointer parameters should of course be valid, except if stated otherwise.
45 // - To ensure compatibility with older programs linked against a former version of the API,
46 // all struct* parameters have an accompanying sizeofstruct parameter.
47 // - Functions returning lists are usually called twice: once with a zero buffer
48 // to get the length of the list, and then again with a buffer of the correct length.
49 
50 //===== #DEFINES ==============================================================
51 
52 #if defined (_WIN32)
53  #if defined AVT_VMBAPI_C_EXPORTS // DLL exports
54  #define IMEXPORTC /*__declspec(dllexport) HINT: We export via the .def file */
55  #elif defined AVT_VMBAPI_C_LIB // static LIB
56  #define IMEXPORTC
57  #else // import
58  #define IMEXPORTC __declspec(dllimport)
59  #endif
60 
61  #ifndef _WIN64
62  // Calling convention
63  #define VMB_CALL __stdcall
64  #else
65  // Calling convention
66  #define VMB_CALL
67  #endif
68 #elif defined (__GNUC__) && (__GNUC__ >= 4) && defined (__ELF__)
69  // SO exports (requires compiler option -fvisibility=hidden)
70  #ifdef AVT_VMBAPI_C_EXPORTS
71  #define IMEXPORTC __attribute__((visibility("default")))
72  #else
73  #define IMEXPORTC
74  #endif
75 
76  #ifdef __i386__
77  // Calling convention
78  #define VMB_CALL __attribute__((stdcall))
79  #else
80  // Calling convention
81  #define VMB_CALL
82  #endif
83 #elif defined (__APPLE__)
84  #define IMEXPORTC __attribute__((visibility("default")))
85  // Calling convention
86  #define VMB_CALL
87 #else
88  #error Unknown platform, file needs adaption
89 #endif
90 
91 //===== TYPES ==============================================================
92 #include "VmbCommonTypes.h"
93 
94 #ifdef __cplusplus
95 extern "C" {
96 #endif
97 
98 // Timeout parameter signaling a blocking call
99 #define VMBINFINITE 0xFFFFFFFF
100 
101 // Constant for the Vimba handle to be able to access Vimba system features
103 
104 //
105 // Camera interface type (for instance FireWire, Ethernet);
106 //
107 typedef enum VmbInterfaceType
108 {
109  VmbInterfaceUnknown = 0, // Interface is not known to this version of the API
110  VmbInterfaceFirewire = 1, // 1394
111  VmbInterfaceEthernet = 2, // GigE
112  VmbInterfaceUsb = 3, // USB 3.0
113  VmbInterfaceCL = 4, // Camera Link
115 typedef VmbUint32_t VmbInterface_t; // Type for an Interface; for values see VmbInterfaceType
116 
117 //
118 // Access mode for configurable devices (interfaces, cameras).
119 // Used in VmbCameraInfo_t, VmbInterfaceInfo_t as flags, so multiple modes can be
120 // announced, while in VmbCameraOpen(), no combination must be used.
121 //
122 typedef enum VmbAccessModeType
123 {
124  VmbAccessModeNone = 0, // No access
125  VmbAccessModeFull = 1, // Read and write access
126  VmbAccessModeRead = 2, // Only read access
127  VmbAccessModeConfig = 4, // Device configuration access
128  VmbAccessModeLite = 8, // Device read/write access without feature access (only addresses)
130 typedef VmbUint32_t VmbAccessMode_t; // Type for an AccessMode; for values see VmbAccessModeType
131 
132 //
133 // Interface information.
134 // Holds read-only information about an interface.
135 //
136 typedef struct
137 {
138  const char* interfaceIdString; // Unique identifier for each interface
139  VmbInterface_t interfaceType; // Interface type, see VmbInterfaceType
140  const char* interfaceName; // Interface name, given by the transport layer
141  const char* serialString; // Serial number
142  VmbAccessMode_t permittedAccess; // Used access mode, see VmbAccessModeType
143 
145 
146 //
147 // Camera information.
148 // Holds read-only information about a camera.
149 //
150 typedef struct
151 {
152  const char* cameraIdString; // Unique identifier for each camera
153  const char* cameraName; // Name of the camera
154  const char* modelName; // Model name
155  const char* serialString; // Serial number
156  VmbAccessMode_t permittedAccess; // Used access mode, see VmbAccessModeType
157  const char* interfaceIdString; // Unique value for each interface or bus
158 
160 
161 //
162 // Supported feature data types
163 //
164 typedef enum VmbFeatureDataType
165 {
166  VmbFeatureDataUnknown = 0, // Unknown feature type
167  VmbFeatureDataInt = 1, // 64 bit integer feature
168  VmbFeatureDataFloat = 2, // 64 bit floating point feature
169  VmbFeatureDataEnum = 3, // Enumeration feature
170  VmbFeatureDataString = 4, // String feature
171  VmbFeatureDataBool = 5, // Boolean feature
172  VmbFeatureDataCommand = 6, // Command feature
173  VmbFeatureDataRaw = 7, // Raw (direct register access) feature
174  VmbFeatureDataNone = 8, // Feature with no data
176 typedef VmbUint32_t VmbFeatureData_t; // Data type for a Feature; for values see VmbFeatureDataType
177 
178 //
179 // Feature visibility
180 //
182 {
184  VmbFeatureVisibilityBeginner = 1, // Feature is visible in feature list (beginner level)
185  VmbFeatureVisibilityExpert = 2, // Feature is visible in feature list (expert level)
186  VmbFeatureVisibilityGuru = 3, // Feature is visible in feature list (guru level)
187  VmbFeatureVisibilityInvisible = 4, // Feature is not visible in feature list
189 typedef VmbUint32_t VmbFeatureVisibility_t; // Type for Feature visibility; for values see VmbFeatureVisibilityType
190 
191 //
192 // Feature flags
193 //
195 {
197  VmbFeatureFlagsRead = 1, // Read access might be permitted (check VmbFeatureAccessQuery())
198  VmbFeatureFlagsWrite = 2, // Write access might be permitted (check VmbFeatureAccessQuery())
199  VmbFeatureFlagsVolatile = 8, // Value may change at any time
200  VmbFeatureFlagsModifyWrite = 16, // Value may change after a write
202 typedef VmbUint32_t VmbFeatureFlags_t; // Type for Feature flags; for values see VmbFeatureFlagsType
203 
204 //
205 // Feature information.
206 // Holds read-only information about a feature.
207 //
208 typedef struct VmbFeatureInfo
209 {
210  const char* name; // Name used in the API
211  VmbFeatureData_t featureDataType; // Data type of this feature
212  VmbFeatureFlags_t featureFlags; // Access flags for this feature
213  const char* category; // Category this feature can be found in
214  const char* displayName; // Feature name to be used in GUIs
215  VmbUint32_t pollingTime; // Predefined polling time for volatile features
216  const char* unit; // Measuring unit as given in the XML file
217  const char* representation; // Representation of a numeric feature
218  VmbFeatureVisibility_t visibility; // GUI visibility
219  const char* tooltip; // Short description, e.g. for a tooltip
220  const char* description; // Longer description
221  const char* sfncNamespace; // Namespace this feature resides in
222  VmbBool_t isStreamable; // Indicates if a feature can be stored to / loaded from a file
223  VmbBool_t hasAffectedFeatures; // Indicates if the feature potentially affects other features
224  VmbBool_t hasSelectedFeatures; // Indicates if the feature selects other features
225 
227 
228 //
229 // Info about possible entries of an enumeration feature
230 //
231 typedef struct VmbFeatureEnumEntry
232 {
233  const char* name; // Name used in the API
234  const char* displayName; // Enumeration entry name to be used in GUIs
235  VmbFeatureVisibility_t visibility; // GUI visibility
236  const char* tooltip; // Short description, e.g. for a tooltip
237  const char* description; // Longer description
238  const char* sfncNamespace; // Namespace this feature resides in
239  VmbInt64_t intValue; // Integer value of this enumeration entry
240 
242 
243 //
244 // Status of a frame transfer
245 //
246 typedef enum VmbFrameStatusType
247 {
248  VmbFrameStatusComplete = 0, // Frame has been completed without errors
249  VmbFrameStatusIncomplete = -1, // Frame could not be filled to the end
250  VmbFrameStatusTooSmall = -2, // Frame buffer was too small
251  VmbFrameStatusInvalid = -3, // Frame buffer was invalid
253 typedef VmbInt32_t VmbFrameStatus_t; // Type for the frame status; for values see VmbFrameStatusType
254 
255 //
256 // Frame flags
257 //
258 typedef enum VmbFrameFlagsType
259 {
261  VmbFrameFlagsDimension = 1, // Frame's dimension is provided
262  VmbFrameFlagsOffset = 2, // Frame's Offset is provided (ROI)
263  VmbFrameFlagsFrameID = 4, // Frame's ID is provided
264  VmbFrameFlagsTimestamp = 8, // Frame's Timestamp is provided
266 typedef VmbUint32_t VmbFrameFlags_t; // Type for Frame flags; for values see VmbFrameFlagsType
267 
268 //
269 // Frame delivered by the camera
270 //
271 typedef struct
272 {
273  //----- In -----
274 
275  void* buffer; // Comprises image and ancillary data
276  VmbUint32_t bufferSize; // Size of the data buffer
277 
278  void* context[4]; // User context filled during queuing
279 
280  //----- Out -----
281  VmbFrameStatus_t receiveStatus; // Resulting status of the receive operation
282  VmbFrameFlags_t receiveFlags; // Resulting flags of the receive operation
283 
284  VmbUint32_t imageSize; // Size of the image data inside the data buffer
285  VmbUint32_t ancillarySize; // Size of the ancillary data inside the data buffer
286 
287  VmbPixelFormat_t pixelFormat; // Pixel format of the image
288 
289  VmbUint32_t width; // Width of an image
290  VmbUint32_t height; // Height of an image
291  VmbUint32_t offsetX; // Horizontal offset of an image
292  VmbUint32_t offsetY; // Vertical offset of an image
293 
294  VmbUint64_t frameID; // Unique ID of this frame in this stream
295  VmbUint64_t timestamp; // Timestamp of the data transfer
296 
297 } VmbFrame_t;
298 
299 // ----- Callbacks ------------------------------------------------------------
300 
301 //
302 // Name: VmbInvalidationCallback
303 //
304 // Purpose: Invalidation Callback type for a function that gets called in a separate thread
305 // and has been registered with VmbFeatureInvalidationRegister()
306 //
307 // Parameters:
308 //
309 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
310 // [in ] const char* name Name of the feature
311 // [in ] void* pUserContext Pointer to the user context, see VmbFeatureInvalidationRegister
312 //
313 // Details: While the callback is run, all feature data is atomic. After the
314 // callback finishes, the feature data might be updated with new values.
315 //
316 // Note: Do not spend too much time in this thread; it will prevent the feature values
317 // from being updated from any other thread or the lower-level drivers.
318 //
319 typedef void (VMB_CALL *VmbInvalidationCallback)( const VmbHandle_t handle, const char* name, void* pUserContext );
320 
321 //
322 // Name: VmbFrameCallback
323 //
324 // Purpose: Frame Callback type for a function that gets called in a separate thread
325 // if a frame has been queued with VmbCaptureFrameQueue()
326 //
327 // Parameters:
328 //
329 // [in ] const VmbHandle_t cameraHandle Handle of the camera
330 // [out] VmbFrame_t* pFrame Frame completed
331 //
332 typedef void (VMB_CALL *VmbFrameCallback)( const VmbHandle_t cameraHandle, VmbFrame_t* pFrame );
333 
334 
335 //===== FUNCTION PROTOTYPES ===================================================
336 
337 //----- API Version -----------------------------------------------------------
338 
339 //
340 // Method: VmbVersionQuery()
341 //
342 // Purpose: Retrieve the version number of VimbaC.
343 //
344 // Parameters:
345 //
346 // [out] VmbVersionInfo_t* pVersionInfo Pointer to the struct where version information
347 // is copied
348 // [in ] VmbUint32_t sizeofVersionInfo Size of structure in bytes
349 //
350 // Returns:
351 //
352 // - VmbErrorSuccess: If no error
353 // - VmbErrorStructSize: The given struct size is not valid for this version of the API
354 // - VmbErrorBadParameter: "pVersionInfo" is NULL.
355 //
356 // Details: This function can be called at anytime, even before the API is
357 // initialized. All other version numbers may be queried via feature access.
358 //
359 IMEXPORTC VmbError_t VMB_CALL VmbVersionQuery ( VmbVersionInfo_t* pVersionInfo,
360  VmbUint32_t sizeofVersionInfo );
361 
362 
363 //----- API Initialization ----------------------------------------------------
364 
365 //
366 // Method: VmbStartup()
367 //
368 // Purpose: Initialize the VimbaC API.
369 //
370 // Parameters:
371 //
372 // Returns:
373 //
374 // - VmbErrorSuccess: If no error
375 // - VmbErrorInternalFault: An internal fault occurred
376 //
377 // Details: On successful return, the API is initialized; this is a necessary call.
378 //
379 // Note: This method must be called before any VimbaC function other than VmbVersionQuery() is run.
380 //
381 IMEXPORTC VmbError_t VMB_CALL VmbStartup ( void );
382 
383 //
384 // Method: VmbShutdown()
385 //
386 // Purpose: Perform a shutdown on the API.
387 //
388 // Parameters: none
389 //
390 // Returns: none
391 //
392 // Details: This will free some resources and deallocate all physical resources if applicable.
393 //
394 IMEXPORTC void VMB_CALL VmbShutdown ( void );
395 
396 
397 //----- Camera Enumeration & Information --------------------------------------
398 
399 //
400 // Method: VmbCamerasList()
401 //
402 // Purpose: Retrieve a list of all cameras.
403 //
404 // Parameters:
405 //
406 // [out] VmbCameraInfo_t* pCameraInfo Array of VmbCameraInfo_t, allocated by
407 // the caller. The camera list is
408 // copied here. May be NULL if pNumFound is used for size query.
409 // [in ] VmbUint32_t listLength Number of VmbCameraInfo_t elements provided
410 // [out] VmbUint32_t* pNumFound Number of VmbCameraInfo_t elements found.
411 // [in ] VmbUint32_t sizeofCameraInfo Size of the structure (if pCameraInfo == NULL this parameter is ignored)
412 //
413 // Returns:
414 //
415 // - VmbErrorSuccess: If no error
416 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
417 // - VmbErrorStructSize: The given struct size is not valid for this API version
418 // - VmbErrorMoreData: The given list length was insufficient to hold all available entries
419 // - VmbErrorBadParameter: The pNumFound parameter was NULL
420 //
421 // Details: Camera detection is started with the registration of the "DiscoveryCameraEvent"
422 // event or the first call of VmbCamerasList(), which may be delayed if no
423 // "DiscoveryCameraEvent" event is registered (see examples).
424 // VmbCamerasList() is usually called twice: once with an empty array to query the
425 // list length, and then again with an array of the correct length. If camera
426 // lists change between the calls, pNumFound may deviate from the query return.
427 //
428 IMEXPORTC VmbError_t VMB_CALL VmbCamerasList ( VmbCameraInfo_t* pCameraInfo,
429  VmbUint32_t listLength,
430  VmbUint32_t* pNumFound,
431  VmbUint32_t sizeofCameraInfo );
432 
433 //
434 // Method: VmbCameraInfoQuery()
435 //
436 // Purpose: Retrieve information on a camera given by an ID.
437 //
438 // Parameters:
439 //
440 // [in ] const char* idString ID of the camera
441 // [out] VmbCameraInfo_t* pInfo Structure where information will be copied. May be NULL.
442 // [in ] VmbUint32_t sizeofCameraInfo Size of the structure
443 //
444 // Returns:
445 //
446 // - VmbErrorSuccess: If no error
447 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
448 // - VmbErrorNotFound: The designated camera cannot be found
449 // - VmbErrorStructSize: The given struct size is not valid for this API version
450 // - VmbErrorBadParameter: idString was NULL
451 //
452 // Details: May be called if a camera has not been opened by the application yet.
453 // Examples for "idString":
454 // "DEV_81237473991" for an ID given by a transport layer,
455 // "169.254.12.13" for an IP address,
456 // "000F314C4BE5" for a MAC address or
457 // "DEV_1234567890" for an ID as reported by Vimba
458 //
459 IMEXPORTC VmbError_t VMB_CALL VmbCameraInfoQuery ( const char* idString,
460  VmbCameraInfo_t* pInfo,
461  VmbUint32_t sizeofCameraInfo );
462 
463 //
464 // Method: VmbCameraOpen()
465 //
466 // Purpose: Open the specified camera.
467 //
468 // Parameters:
469 //
470 // [in ] const char* idString ID of the camera
471 // [in ] VmbAccessMode_t accessMode Determines the level of control you have on the camera
472 // [out] VmbHandle_t* pCameraHandle A camera handle
473 //
474 // Returns:
475 //
476 // - VmbErrorSuccess: If no error
477 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
478 // - VmbErrorNotFound: The designated camera cannot be found
479 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
480 // - VmbErrorInvalidCall: if called from frame callback
481 // - VmbErrorBadParameter: if idString or pCameraHandle is NULL
482 //
483 // Details: A camera may be opened in a specific access mode, which determines
484 // the level of control you have on a camera.
485 // Examples for "idString":
486 // "DEV_81237473991" for an ID given by a transport layer,
487 // "169.254.12.13" for an IP address,
488 // "000F314C4BE5" for a MAC address or
489 // "DEV_1234567890" for an ID as reported by Vimba
490 //
491 IMEXPORTC VmbError_t VMB_CALL VmbCameraOpen ( const char* idString,
492  VmbAccessMode_t accessMode,
493  VmbHandle_t* pCameraHandle );
494 
495 //
496 // Method: VmbCameraClose()
497 //
498 // Purpose: Close the specified camera.
499 //
500 // Parameters:
501 //
502 // [in ] const VmbHandle_t cameraHandle A valid camera handle
503 //
504 // Returns:
505 //
506 // - VmbErrorSuccess: If no error
507 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
508 // - VmbErrorInvalidCall: If called from frame callback
509 //
510 // Details: Depending on the access mode this camera was opened with, events are killed,
511 // callbacks are unregistered, and camera control is released.
512 //
513 IMEXPORTC VmbError_t VMB_CALL VmbCameraClose ( const VmbHandle_t cameraHandle );
514 
515 
516 //----- Features ----------------------------------------------------------
517 
518 //
519 // Method: VmbFeaturesList()
520 //
521 // Purpose: List all the features for this entity.
522 //
523 // Parameters:
524 //
525 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
526 // [out] VmbFeatureInfo_t* pFeatureInfoList An array of VmbFeatureInfo_t to be filled by the API. May be NULL if pNumFund is used for size query.
527 // [in ] VmbUint32_t listLength Number of VmbFeatureInfo_t elements provided
528 // [out] VmbUint32_t* pNumFound Number of VmbFeatureInfo_t elements found. May be NULL if pFeatureInfoList is not NULL.
529 // [in ] VmbUint32_t sizeofFeatureInfo Size of a VmbFeatureInfo_t entry
530 //
531 // Returns:
532 //
533 // - VmbErrorSuccess: If no error
534 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
535 // - VmbErrorBadHandle: The given handle is not valid
536 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
537 // - VmbErrorStructSize: The given struct size of VmbFeatureInfo_t is not valid for this version of the API
538 // - VmbErrorMoreData: The given list length was insufficient to hold all available entries
539 //
540 // Details: This method lists all implemented features, whether they are currently available or not.
541 // The list of features does not change as long as the camera/interface is connected.
542 // "pNumFound" returns the number of VmbFeatureInfo elements.
543 // This function is usually called twice: once with an empty list to query the length
544 // of the list, and then again with an list of the correct length.
545 //
546 //
547 IMEXPORTC VmbError_t VMB_CALL VmbFeaturesList ( const VmbHandle_t handle,
548  VmbFeatureInfo_t* pFeatureInfoList,
549  VmbUint32_t listLength,
550  VmbUint32_t* pNumFound,
551  VmbUint32_t sizeofFeatureInfo );
552 
553 //
554 // Method: VmbFeatureInfoQuery()
555 //
556 // Purpose: Query information about the constant properties of a feature.
557 //
558 // Parameters:
559 //
560 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
561 // [in ] const char* name Name of the feature
562 // [out] VmbFeatureInfo_t* pFeatureInfo The feature info to query
563 // [in ] VmbUint32_t sizeofFeatureInfo Size of the structure
564 //
565 // Returns:
566 //
567 // - VmbErrorSuccess: If no error
568 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
569 // - VmbErrorBadHandle: The given handle is not valid
570 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
571 // - VmbErrorStructSize: The given struct size is not valid for this version of the API
572 //
573 // Details: Users provide a pointer to VmbFeatureInfo_t, which is then set to the internal representation.
574 //
575 IMEXPORTC VmbError_t VMB_CALL VmbFeatureInfoQuery ( const VmbHandle_t handle,
576  const char* name,
577  VmbFeatureInfo_t* pFeatureInfo,
578  VmbUint32_t sizeofFeatureInfo );
579 
580 //
581 // Method: VmbFeatureListAffected()
582 //
583 // Purpose: List all the features that might be affected by changes to this feature.
584 //
585 // Parameters:
586 //
587 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
588 // [in ] const char* name Name of the feature
589 // [out] VmbFeatureInfo_t* pFeatureInfoList An array of VmbFeatureInfo_t to be filled by the API. May be NULL if pNumFound is used for size query.
590 // [in ] VmbUint32_t listLength Number of VmbFeatureInfo_t elements provided
591 // [out] VmbUint32_t* pNumFound Number of VmbFeatureInfo_t elements found. May be NULL is pFeatureInfoList is not NULL.
592 // [in ] VmbUint32_t sizeofFeatureInfo Size of a VmbFeatureInfo_t entry
593 //
594 // Returns:
595 //
596 // - VmbErrorSuccess: If no error
597 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
598 // - VmbErrorBadHandle: The given handle is not valid
599 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
600 // - VmbErrorStructSize: The given struct size of VmbFeatureInfo_t is not valid for this version of the API
601 // - VmbErrorMoreData: The given list length was insufficient to hold all available entries
602 //
603 // Details: This method lists all affected features, whether they are currently available or not.
604 // The value of affected features depends directly or indirectly on this feature
605 // (including all selected features).
606 // The list of features does not change as long as the camera/interface is connected.
607 // This function is usually called twice: once with an empty array to query the length
608 // of the list, and then again with an array of the correct length.
609 //
610 IMEXPORTC VmbError_t VMB_CALL VmbFeatureListAffected ( const VmbHandle_t handle,
611  const char* name,
612  VmbFeatureInfo_t* pFeatureInfoList,
613  VmbUint32_t listLength,
614  VmbUint32_t* pNumFound,
615  VmbUint32_t sizeofFeatureInfo );
616 
617 //
618 // Method: VmbFeatureListSelected()
619 //
620 // Purpose: List all the features selected by a given feature for this module.
621 //
622 // Parameters:
623 //
624 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
625 // [in ] const char* name Name of the feature
626 // [out] VmbFeatureInfo_t* pFeatureInfoList An array of VmbFeatureInfo_t to be filled by the API. May be NULL if pNumFound is used for size query.
627 // [in ] VmbUint32_t listLength Number of VmbFeatureInfo_t elements provided
628 // [out] VmbUint32_t* pNumFound Number of VmbFeatureInfo_t elements found. May be NULL if pFeatureInfoList is not NULL.
629 // [in ] VmbUint32_t sizeofFeatureInfo Size of a VmbFeatureInfo_t entry
630 //
631 // Returns:
632 //
633 // - VmbErrorSuccess: If no error
634 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
635 // - VmbErrorBadHandle: The given handle is not valid
636 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
637 // - VmbErrorStructSize: The given struct size is not valid for this version of the API
638 // - VmbErrorMoreData: The given list length was insufficient to hold all available entries
639 //
640 // Details: This method lists all selected features, whether they are currently available or not.
641 // Features with selected features ("selectors") have no direct impact on the camera,
642 // but only influence the register address that selected features point to.
643 // The list of features does not change while the camera/interface is connected.
644 // This function is usually called twice: once with an empty array to query the length
645 // of the list, and then again with an array of the correct length.
646 //
647 IMEXPORTC VmbError_t VMB_CALL VmbFeatureListSelected ( const VmbHandle_t handle,
648  const char* name,
649  VmbFeatureInfo_t* pFeatureInfoList,
650  VmbUint32_t listLength,
651  VmbUint32_t* pNumFound,
652  VmbUint32_t sizeofFeatureInfo );
653 
654 //
655 // Method: VmbFeatureAccessQuery()
656 //
657 // Purpose: Return the dynamic read and write capabilities of this feature.
658 //
659 // Parameters:
660 //
661 // [in ] const VmbHandle_t handle Handle for an entity that exposes features.
662 // [in ] const char * name Name of the feature.
663 // [out] VmbBool_t * pIsReadable Indicates if this feature is readable. May be NULL.
664 // [out] VmbBool_t * pIsWriteable Indicates if this feature is writable. May be NULL.
665 //
666 // Returns:
667 //
668 // - VmbErrorSuccess: If no error
669 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
670 // - VmbErrorBadHandle: The given handle is not valid
671 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
672 // - VmbErrorBadParameter: pIsReadable and pIsWriteable were both NULL
673 // - VmbErrorNotFound: The feature was not found
674 //
675 // Details: The access mode of a feature may change. For example, if "PacketSize"
676 // is locked while image data is streamed, it is only readable.
677 //
678 IMEXPORTC VmbError_t VMB_CALL VmbFeatureAccessQuery ( const VmbHandle_t handle,
679  const char* name,
680  VmbBool_t * pIsReadable,
681  VmbBool_t * pIsWriteable );
682 
683 
684 //-----Integer --------
685 
686 //
687 // Method: VmbFeatureIntGet()
688 //
689 // Purpose: Get the value of an integer feature.
690 //
691 // Parameters:
692 //
693 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
694 // [in ] const char* name Name of the feature
695 // [out] VmbInt64_t* pValue Value to get
696 //
697 // Returns:
698 //
699 // - VmbErrorSuccess: If no error
700 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
701 // - VmbErrorBadHandle: The given handle is not valid
702 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
703 // - VmbErrorWrongType: The type of feature "name" is not Integer
704 // - VmbErrorNotFound: The feature was not found
705 // - VmbErrorBadParameter: If name or pValue is NULL
706 //
707 IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntGet ( const VmbHandle_t handle,
708  const char* name,
709  VmbInt64_t* pValue );
710 
711 //
712 // Method: VmbFeatureIntSet()
713 //
714 // Purpose: Set the value of an integer feature.
715 //
716 // Parameters:
717 //
718 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
719 // [in ] const char* name Name of the feature
720 // [in ] VmbInt64_t value Value to set
721 //
722 // Returns:
723 //
724 // - VmbErrorSuccess: If no error
725 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
726 // - VmbErrorBadHandle: The given handle is not valid
727 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
728 // - VmbErrorWrongType: The type of feature "name" is not Integer
729 // - VmbErrorInvalidValue: "value" is either out of bounds or not an increment of the minimum
730 // - VmbErrorBadParameter: If name is NULL
731 // - VmbErrorNotFound: If the feature was not found
732 // - VmbErrorInvalidCall: If called from frame callback
733 //
734 IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntSet ( const VmbHandle_t handle,
735  const char* name,
736  VmbInt64_t value );
737 
738 //
739 // Method: VmbFeatureIntRangeQuery()
740 //
741 // Purpose: Query the range of an integer feature.
742 //
743 // Parameters:
744 //
745 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
746 // [in ] const char* name Name of the feature
747 // [out] VmbInt64_t* pMin Minimum value to be returned. May be NULL.
748 // [out] VmbInt64_t* pMax Maximum value to be returned. May be NULL.
749 //
750 // Returns:
751 //
752 // - VmbErrorSuccess: If no error
753 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
754 // - VmbErrorBadHandle: The given handle is not valid
755 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
756 // - VmbErrorBadParameter: If name is NULL or pMin and pMax are NULL
757 // - VmbErrorWrongType: The type of feature "name" is not Integer
758 // - VmbErrorNotFound: If the feature was not found
759 //
760 IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntRangeQuery ( const VmbHandle_t handle,
761  const char* name,
762  VmbInt64_t* pMin,
763  VmbInt64_t* pMax );
764 
765 //
766 // Method: VmbFeatureIntIncrementQuery()
767 //
768 // Purpose: Query the increment of an integer feature.
769 //
770 // Parameters:
771 //
772 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
773 // [in ] const char* name Name of the feature
774 // [out] VmbInt64_t* pValue Value of the increment to get.
775 //
776 // Returns:
777 //
778 // - VmbErrorSuccess: If no error
779 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
780 // - VmbErrorBadHandle: The given handle is not valid
781 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
782 // - VmbErrorWrongType: The type of feature "name" is not Integer
783 // - VmbErrorNotFound: The feature was not found
784 // VmbErrorBadParameter: IF name or pValue is NULL
785 //
786 IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntIncrementQuery ( const VmbHandle_t handle,
787  const char* name,
788  VmbInt64_t* pValue );
789 
790 //-----Float --------
791 
792 //
793 // Method: VmbFeatureFloatGet()
794 //
795 // Purpose: Get the value of a float feature.
796 //
797 // Parameters:
798 //
799 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
800 // [in ] const char* name Name of the feature
801 // [out] double* pValue Value to get
802 //
803 // Returns:
804 //
805 // - VmbErrorSuccess: If no error
806 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
807 // - VmbErrorBadHandle: The given handle is not valid
808 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
809 // - VmbErrorWrongType: The type of feature "name" is not Float
810 // - VmbErrorBadParameter: If name or pValue is NULL
811 // - VmbErrorNotFound: The feature was not found
812 //
813 IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatGet ( const VmbHandle_t handle,
814  const char* name,
815  double* pValue );
816 
817 //
818 // Method: VmbFeatureFloatSet()
819 //
820 // Purpose: Set the value of a float feature.
821 //
822 // Parameters:
823 //
824 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
825 // [in ] const char* name Name of the feature
826 // [in ] double value Value to set
827 //
828 // Returns:
829 //
830 // - VmbErrorSuccess: If no error
831 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
832 // - VmbErrorBadHandle: The given handle is not valid
833 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
834 // - VmbErrorWrongType: The type of feature "name" is not Float
835 // - VmbErrorInvalidValue: "value" is not within valid bounds
836 // - VmbErrorNotFound: The feature was not found
837 // - VmbErrorBadParameter: If name is NULL
838 // - VmbErrorInvalidCall: If called from frame callback
839 //
840 IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatSet ( const VmbHandle_t handle,
841  const char* name,
842  double value );
843 
844 //
845 // Method: VmbFeatureFloatRangeQuery()
846 //
847 // Purpose: Query the range of a float feature.
848 //
849 // Parameters:
850 //
851 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
852 // [in ] const char* name Name of the feature
853 // [out] double* pMin Minimum value to be returned. May be NULL.
854 // [out] double* pMax Maximum value to be returned. May be NULL.
855 //
856 // Returns:
857 //
858 // - VmbErrorSuccess: If no error
859 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
860 // - VmbErrorBadHandle: The given handle is not valid
861 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
862 // - VmbErrorWrongType: The type of feature "name" is not Float
863 // - VmbErrorNotFound: The feature was not found
864 // - VmbBadParameter: If name is NULL or pMin and pMax are NULL
865 //
866 // Details: Only one of the values may be queried if the other parameter is set to NULL,
867 // but if both parameters are NULL, an error is returned.
868 //
869 IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatRangeQuery ( const VmbHandle_t handle,
870  const char* name,
871  double* pMin,
872  double* pMax );
873 
874 //
875 // Method: VmbFeatureFloatIncrementQuery()
876 //
877 // Purpose: Query the increment of an float feature.
878 //
879 // Parameters:
880 //
881 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
882 // [in ] const char* name Name of the feature
883 // [out] double* pValue Value of the increment to get.
884 //
885 // Returns:
886 //
887 // - VmbErrorSuccess: If no error
888 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
889 // - VmbErrorBadHandle: The given handle is not valid
890 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
891 // - VmbErrorWrongType: The type of feature "name" is not Integer
892 // - VmbErrorNotFound: The feature was not found
893 // VmbErrorBadParameter: IF name or pValue is NULL
894 //
895 IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatIncrementQuery ( const VmbHandle_t handle,
896  const char* name,
897  VmbBool_t* hasIncrement,
898  double* pValue );
899 //-----Enum --------
900 
901 //
902 // Method: VmbFeatureEnumGet()
903 //
904 // Purpose: Get the value of an enumeration feature.
905 //
906 // Parameters:
907 //
908 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
909 // [in ] const char* name Name of the feature
910 // [out] const char** pValue The current enumeration value. The returned value
911 // is a reference to the API value
912 //
913 // Returns:
914 //
915 // - VmbErrorSuccess: If no error
916 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
917 // - VmbErrorBadHandle: The given handle is not valid
918 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
919 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
920 // - VmbErrorNotFound: The feature was not found
921 // - VmbErrorBadParameter: if name or pValue is NULL
922 //
923 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumGet ( const VmbHandle_t handle,
924  const char* name,
925  const char** pValue );
926 
927 //
928 // Method: VmbFeatureEnumSet()
929 //
930 // Purpose: Set the value of an enumeration feature.
931 //
932 // Parameters:
933 //
934 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
935 // [in ] const char* name Name of the feature
936 // [in ] const char* value Value to set
937 //
938 // Returns:
939 //
940 // - VmbErrorSuccess: If no error
941 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
942 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
943 // - VmbErrorBadHandle: The given handle is not valid
944 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
945 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
946 // - VmbErrorInvalidValue: "value" is not within valid bounds
947 // - VmbErrorNotFound: The feature was not found
948 // - VmbErrorBadParameter: If name ore value is NULL
949 // - VmbErrorInvalidCall: If called from frame callback
950 //
951 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumSet ( const VmbHandle_t handle,
952  const char* name,
953  const char* value );
954 
955 //
956 // Method: VmbFeatureEnumRangeQuery()
957 //
958 // Purpose: Query the value range of an enumeration feature.
959 //
960 // Parameters:
961 //
962 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
963 // [in ] const char* name Name of the feature
964 // [out] const char* const* pNameArray An Array of enumeration value names may be NULL if pNumFilled is used for size query
965 // [in ] VmbUint32_t arrayLength Number of elements in the array
966 // [out] VmbUint32_t * pNumFilled Number of filled elements my be NULL if pNameArray is not NULL
967 //
968 // Returns:
969 //
970 // - VmbErrorSuccess: If no error
971 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
972 // - VmbErrorBadHandle: The given handle is not valid
973 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
974 // - VmbErrorMoreData: The given array length was insufficient to hold all available entries
975 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
976 // - VmbErrorNotFound: The feature was not found
977 // - VmbErrorBadParameter: if name is NULL or pNameArray and pNumFilled are NULL
978 //
979 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumRangeQuery ( const VmbHandle_t handle,
980  const char* name,
981  const char** pNameArray,
982  VmbUint32_t arrayLength,
983  VmbUint32_t* pNumFilled );
984 
985 //
986 // Method: VmbFeatureEnumIsAvailable()
987 //
988 // Purpose: Check if a certain value of an enumeration is available.
989 //
990 // Parameters:
991 //
992 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
993 // [in ] const char* name Name of the feature
994 // [in ] const char* value Value to check
995 // [out] VmbBool_t * pIsAvailable Indicates if the given enumeration value is available
996 //
997 // Returns:
998 //
999 // - VmbErrorSuccess: If no error
1000 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1001 // - VmbErrorBadHandle: The given handle is not valid
1002 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1003 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
1004 // - VmbErrorNotFound: The feature was not found
1005 // - VmbErrorBadParameter: if name or value or pIsAvailable is NULL
1006 //
1007 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumIsAvailable ( const VmbHandle_t handle,
1008  const char* name,
1009  const char* value,
1010  VmbBool_t * pIsAvailable );
1011 
1012 //
1013 // Method: VmbFeatureEnumAsInt()
1014 //
1015 // Purpose: Get the integer value for a given enumeration string value.
1016 //
1017 // Parameters:
1018 //
1019 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1020 // [in ] const char* name Name of the feature
1021 // [in ] const char* value The enumeration value to get the integer value for
1022 // [out] VmbInt64_t* pIntVal The integer value for this enumeration entry
1023 //
1024 // Returns:
1025 //
1026 // - VmbErrorSuccess: If no error
1027 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1028 // - VmbErrorBadHandle: The given handle is not valid
1029 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1030 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
1031 // - VmbErrorNotFound: The feature was not found
1032 // - VmbErrorBadParameter: if name or value pIntVal is NULL
1033 //
1034 // Details: Converts a name of an enum member into an int value ("Mono12Packed" to 0x10C0006)
1035 //
1036 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumAsInt ( const VmbHandle_t handle,
1037  const char* name,
1038  const char* value,
1039  VmbInt64_t* pIntVal );
1040 
1041 //
1042 // Method: VmbFeatureEnumAsString()
1043 //
1044 // Purpose: Get the enumeration string value for a given integer value.
1045 //
1046 // Parameters:
1047 //
1048 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1049 // [in ] const char* name Name of the feature
1050 // [in ] VmbInt64_t intValue The numeric value
1051 // [out] const char** pStringValue The string value for the numeric value
1052 //
1053 // Returns:
1054 //
1055 // - VmbErrorSuccess: If no error
1056 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1057 // - VmbErrorBadHandle: The given handle is not valid
1058 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1059 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
1060 // - VmbErrorNotFound: The feature was not found
1061 // - VmbErrorBadParameter: If name or pStringValue is NULL
1062 //
1063 // Details: Converts an int value to a name of an enum member (e.g. 0x10C0006 to "Mono12Packed")
1064 //
1065 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumAsString ( const VmbHandle_t handle,
1066  const char* name,
1067  VmbInt64_t intValue,
1068  const char** pStringValue );
1069 
1070 //
1071 // Method: VmbFeatureEnumEntryGet()
1072 //
1073 // Purpose: Get infos about an entry of an enumeration feature.
1074 //
1075 // Parameters:
1076 //
1077 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1078 // [in ] const char* featureName Name of the feature
1079 // [in ] const char* entryName Name of the enum entry of that feature
1080 // [out] VmbFeatureEnumEntry_t* pFeatureEnumEntry Infos about that entry returned by the API
1081 // [in] VmbUint32_t sizeofFeatureEnumEntry Size of the structure
1082 //
1083 // Returns:
1084 //
1085 // - VmbErrorSuccess: If no error
1086 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1087 // - VmbErrorBadHandle: The given handle is not valid
1088 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1089 // - VmbErrorStructSize Size of VmbFeatureEnumEntry_t is not compatible with the API version
1090 // - VmbErrorWrongType: The type of feature "name" is not Enumeration
1091 // - VmbErrorNotFound: The feature was not found
1092 // - VmbErrorBadParameter: if featureName or entryName or pFeatureEnumEntry is NULL
1093 //
1094 IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumEntryGet ( const VmbHandle_t handle,
1095  const char* featureName,
1096  const char* entryName,
1097  VmbFeatureEnumEntry_t* pFeatureEnumEntry,
1098  VmbUint32_t sizeofFeatureEnumEntry );
1099 
1100 //-----String --------
1101 
1102 //
1103 // Method: VmbFeatureStringGet()
1104 //
1105 // Purpose: Get the value of a string feature.
1106 //
1107 // Parameters:
1108 //
1109 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1110 // [in ] const char* name Name of the string feature
1111 // [out] char* buffer String buffer to fill. May be NULL if pSizeFilled is used for size query.
1112 // [in ] VmbUint32_t bufferSize Size of the input buffer
1113 // [out] VmbUint32_t* pSizeFilled Size actually filled my be NULL if buffer is not NULL.
1114 //
1115 // Returns:
1116 //
1117 // - VmbErrorSuccess: If no error
1118 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1119 // - VmbErrorBadHandle: The given handle is not valid
1120 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1121 // - VmbErrorMoreData: The given buffer size was too small
1122 // - VmbErrorNotFound: The feature was not found
1123 // - VmbErrorWrongType: The type of feature "name" is not String
1124 //
1125 // Details: This function is usually called twice: once with an empty buffer to query the length
1126 // of the string, and then again with a buffer of the correct length.
1127 
1128 IMEXPORTC VmbError_t VMB_CALL VmbFeatureStringGet ( const VmbHandle_t handle,
1129  const char* name,
1130  char* buffer,
1131  VmbUint32_t bufferSize,
1132  VmbUint32_t* pSizeFilled );
1133 
1134 //
1135 // Method: VmbFeatureStringSet()
1136 //
1137 // Purpose: Set the value of a string feature.
1138 //
1139 // Parameters:
1140 //
1141 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1142 // [in ] const char* name Name of the string feature
1143 // [in ] const char* value Value to set
1144 //
1145 // Returns:
1146 //
1147 // - VmbErrorSuccess: If no error
1148 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1149 // - VmbErrorBadHandle: The given handle is not valid
1150 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1151 // - VmbErrorNotFound: The feature was not found
1152 // - VmbErrorWrongType: The type of feature "name" is not String
1153 // - VmbErrorInvalidValue: Length of "value" exceeded the maximum length
1154 // - VmbErrorBadParameter: if name or value is NULL
1155 // - VmbErrorInvalidCall: If called from frame callback
1156 //
1157 IMEXPORTC VmbError_t VMB_CALL VmbFeatureStringSet ( const VmbHandle_t handle,
1158  const char* name,
1159  const char* value );
1160 
1161 //
1162 // Method: VmbFeatureStringMaxlengthQuery()
1163 //
1164 // Purpose: Get the maximum length of a string feature.
1165 //
1166 // Parameters:
1167 //
1168 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1169 // [in ] const char* name Name of the string feature
1170 // [out] VmbUint32_t* pMaxLength Maximum length of this string feature
1171 //
1172 // Returns:
1173 //
1174 // - VmbErrorSuccess: If no error
1175 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1176 // - VmbErrorBadHandle: The given handle is not valid
1177 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1178 // - VmbErrorWrongType: The type of feature "name" is not String
1179 // - VmbErrorBadParameter: If name or pMaxLength is NULL
1180 //
1181 IMEXPORTC VmbError_t VMB_CALL VmbFeatureStringMaxlengthQuery ( const VmbHandle_t handle,
1182  const char* name,
1183  VmbUint32_t* pMaxLength );
1184 
1185 //-----Boolean --------
1186 
1187 //
1188 // Method: VmbFeatureBoolGet()
1189 //
1190 // Purpose: Get the value of a boolean feature.
1191 //
1192 // Parameters:
1193 //
1194 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1195 // [in ] const char* name Name of the boolean feature
1196 // [out] VmbBool_t * pValue Value to be read
1197 //
1198 // Returns:
1199 //
1200 // - VmbErrorSuccess: If no error
1201 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1202 // - VmbErrorBadHandle: The given handle is not valid
1203 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1204 // - VmbErrorWrongType: The type of feature "name" is not Boolean
1205 // - VmbErrorNotFound: If feature is not found
1206 // - VmbErrorBadParameter: If name or pValue is NULL
1207 //
1208 IMEXPORTC VmbError_t VMB_CALL VmbFeatureBoolGet ( const VmbHandle_t handle,
1209  const char* name,
1210  VmbBool_t * pValue );
1211 
1212 //
1213 // Method: VmbFeatureBoolSet()
1214 //
1215 // Purpose: Set the value of a boolean feature.
1216 //
1217 // Parameters:
1218 //
1219 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1220 // [in ] const char* name Name of the boolean feature
1221 // [in ] VmbBool_t value Value to write
1222 //
1223 // Returns:
1224 //
1225 // - VmbErrorSuccess: If no error
1226 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1227 // - VmbErrorBadHandle: The given handle is not valid
1228 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1229 // - VmbErrorWrongType: The type of feature "name" is not Boolean
1230 // - VmbErrorInvalidValue: "value" is not within valid bounds
1231 // - VmbErrorNotFound: If the feature is not found
1232 // - VmbErrorBadParameter: name is NULL
1233 // - VmbErrorInvalidCall: If called from frame callback
1234 //
1235 IMEXPORTC VmbError_t VMB_CALL VmbFeatureBoolSet ( const VmbHandle_t handle,
1236  const char* name,
1237  VmbBool_t value );
1238 
1239 //-----Command ------
1240 
1241 //
1242 // Method: VmbFeatureCommandRun()
1243 //
1244 // Purpose: Run a feature command.
1245 //
1246 // Parameters:
1247 //
1248 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1249 // [in ] const char* name Name of the command feature
1250 //
1251 // Returns:
1252 //
1253 // - VmbErrorSuccess: If no error
1254 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1255 // - VmbErrorBadHandle: The given handle is not valid
1256 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1257 // - VmbErrorWrongType: The type of feature "name" is not Command
1258 // - VmbErrorNotFound: Feature was not found
1259 // - VmbErrorBadParameter: name is NULL
1260 //
1261 IMEXPORTC VmbError_t VMB_CALL VmbFeatureCommandRun ( const VmbHandle_t handle,
1262  const char* name );
1263 
1264 //
1265 // Method: VmbFeatureCommandIsDone()
1266 //
1267 // Purpose: Check if a feature command is done.
1268 //
1269 // Parameters:
1270 //
1271 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1272 // [in ] const char* name Name of the command feature
1273 // [out] VmbBool_t * pIsDone State of the command.
1274 //
1275 // Returns:
1276 //
1277 // - VmbErrorSuccess: If no error
1278 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1279 // - VmbErrorBadHandle: The given handle is not valid
1280 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1281 // - VmbErrorWrongType: The type of feature "name" is not Command
1282 // - VmbErrorNotFound: Feature was not found
1283 // - VmbErrorBadParameter: name or pIsDone is NULL
1284 //
1285 IMEXPORTC VmbError_t VMB_CALL VmbFeatureCommandIsDone ( const VmbHandle_t handle,
1286  const char* name,
1287  VmbBool_t * pIsDone );
1288 
1289 //-----Raw --------
1290 
1291 //
1292 // Method: VmbFeatureRawGet()
1293 //
1294 // Purpose: Read the memory contents of an area given by a feature name.
1295 //
1296 // Parameters:
1297 //
1298 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1299 // [in ] const char* name Name of the raw feature
1300 // [out] char* pBuffer Buffer to fill
1301 // [in ] VmbUint32_t bufferSize Size of the buffer to be filled
1302 // [out] VmbUint32_t* pSizeFilled Number of bytes actually filled
1303 //
1304 // Returns:
1305 //
1306 // - VmbErrorSuccess: If no error
1307 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1308 // - VmbErrorBadHandle: The given handle is not valid
1309 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1310 // - VmbErrorWrongType: The type of feature "name" is not Register
1311 // - VmbErrorNotFound: Feature was not found
1312 // - VmbErrorBadParameter: If name or pBuffer or pSizeFilled is NULL
1313 //
1314 // Details: This feature type corresponds to a top-level "Register" feature in GenICam.
1315 // Data transfer is split up by the transport layer if the feature length is too large.
1316 // You can get the size of the memory area addressed by the feature "name" by VmbFeatureRawLengthQuery().
1317 //
1318 IMEXPORTC VmbError_t VMB_CALL VmbFeatureRawGet ( const VmbHandle_t handle,
1319  const char* name,
1320  char* pBuffer,
1321  VmbUint32_t bufferSize,
1322  VmbUint32_t* pSizeFilled );
1323 
1324 //
1325 // Method: VmbFeatureRawSet()
1326 //
1327 // Purpose: Write to a memory area given by a feature name.
1328 //
1329 // Parameters:
1330 //
1331 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1332 // [in ] const char* name Name of the raw feature
1333 // [in ] const char* pBuffer Data buffer to use
1334 // [in ] VmbUint32_t bufferSize Size of the buffer
1335 //
1336 // Returns:
1337 //
1338 // - VmbErrorSuccess: If no error
1339 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1340 // - VmbErrorBadHandle: The given handle is not valid
1341 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1342 // - VmbErrorWrongType: The type of feature "name" is not Register
1343 // - VmbErrorNotFound: Feature was not found
1344 // - VmbErrorBadParameter: If name or pBuffer is NULL
1345 // - VmbErrorInvalidCall: If called from frame callback
1346 //
1347 // Details: This feature type corresponds to a first-level "Register" node in the XML file.
1348 // Data transfer is split up by the transport layer if the feature length is too large.
1349 // You can get the size of the memory area addressed by the feature "name" by VmbFeatureRawLengthQuery().
1350 //
1351 IMEXPORTC VmbError_t VMB_CALL VmbFeatureRawSet ( const VmbHandle_t handle,
1352  const char* name,
1353  const char* pBuffer,
1354  VmbUint32_t bufferSize );
1355 
1356 //
1357 // Method: VmbFeatureRawLengthQuery()
1358 //
1359 // Purpose: Get the length of a raw feature for memory transfers.
1360 //
1361 // Parameters:
1362 //
1363 // [in ] const VmbHandle_t handle Handle for an entity that exposes features
1364 // [in ] const char* name Name of the raw feature
1365 // [out] VmbUint32_t* pLength Length of the raw feature area (in bytes)
1366 //
1367 // Returns:
1368 //
1369 // - VmbErrorSuccess: If no error
1370 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1371 // - VmbErrorBadHandle: The given handle is not valid
1372 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1373 // - VmbErrorWrongType: The type of feature "name" is not Register
1374 // - VmbErrorNotFound: Feature not found
1375 // - VmbErrorBadParameter: If name or pLength is NULL
1376 //
1377 // Details: This feature type corresponds to a first-level "Register" node in the XML file.
1378 //
1379 IMEXPORTC VmbError_t VMB_CALL VmbFeatureRawLengthQuery ( const VmbHandle_t handle,
1380  const char* name,
1381  VmbUint32_t* pLength );
1382 
1383 //----- Feature invalidation --------------------------------------------------------
1384 
1385 //
1386 // Method: VmbFeatureInvalidationRegister()
1387 //
1388 // Purpose: Register a VmbInvalidationCallback callback for feature invalidation signaling.
1389 //
1390 // Parameters:
1391 //
1392 // [in ] const VmbHandle_t handle Handle for an entity that emits events
1393 // [in ] const char* name Name of the event (NULL to register for any feature)
1394 // [in ] VmbInvalidationCallback callback Callback to be run, when invalidation occurs
1395 // [in ] void* pUserContext User context passed to function
1396 //
1397 // Returns:
1398 //
1399 // - VmbErrorSuccess: If no error
1400 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1401 // - VmbErrorBadHandle: The given handle is not valid
1402 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1403 //
1404 // Details: Any feature change, either of its value or of its access state, may be tracked
1405 // by registering an invalidation callback.
1406 // Registering multiple callbacks for one feature invalidation event is possible because
1407 // only the combination of handle, name, and callback is used as key. If the same
1408 // combination of handle, name, and callback is registered a second time, it overwrites
1409 // the previous one.
1410 //
1411 IMEXPORTC VmbError_t VMB_CALL VmbFeatureInvalidationRegister ( const VmbHandle_t handle,
1412  const char* name,
1413  VmbInvalidationCallback callback,
1414  void* pUserContext );
1415 
1416 //
1417 // Method: VmbFeatureInvalidationUnregister()
1418 //
1419 // Purpose: Unregister a previously registered feature invalidation callback.
1420 //
1421 // Parameters:
1422 //
1423 // [in ] const VmbHandle_t handle Handle for an entity that emits events
1424 // [in ] const char* name Name of the event
1425 // [in ] VmbInvalidationCallback callback Callback to be removed
1426 //
1427 // Returns:
1428 //
1429 // - VmbErrorSuccess: If no error
1430 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1431 // - VmbErrorBadHandle: The given handle is not valid
1432 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1433 //
1434 // Details: Since multiple callbacks may be registered for a feature invalidation event,
1435 // a combination of handle, name, and callback is needed for unregistering, too.
1436 //
1437 IMEXPORTC VmbError_t VMB_CALL VmbFeatureInvalidationUnregister ( const VmbHandle_t handle,
1438  const char* name,
1439  VmbInvalidationCallback callback );
1440 
1441 
1442 //----- Image preparation and acquisition ---------------------------------------------------
1443 
1444 //
1445 // Method: VmbFrameAnnounce()
1446 //
1447 // Purpose: Announce frames to the API that may be queued for frame capturing later.
1448 //
1449 // Parameters:
1450 //
1451 // [in ] const VmbHandle_t cameraHandle Handle for a camera
1452 // [in ] const VmbFrame_t* pFrame Frame buffer to announce
1453 // [in ] VmbUint32_t sizeofFrame Size of the frame structure
1454 //
1455 // Returns:
1456 //
1457 // - VmbErrorSuccess: If no error
1458 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1459 // - VmbErrorBadHandle: The given camera handle is not valid
1460 // - VmbErrorBadParameter: The given frame pointer is not valid or sizeofFrame is 0
1461 // - VmbErrorStructSize: The given struct size is not valid for this version of the API
1462 //
1463 // Details: Allows some preparation for frames like DMA preparation depending on the transport layer.
1464 // The order in which the frames are announced is not taken into consideration by the API.
1465 //
1466 IMEXPORTC VmbError_t VMB_CALL VmbFrameAnnounce ( const VmbHandle_t cameraHandle,
1467  const VmbFrame_t* pFrame,
1468  VmbUint32_t sizeofFrame );
1469 
1470 
1471 //
1472 // Method: VmbFrameRevoke()
1473 //
1474 // Purpose: Revoke a frame from the API.
1475 //
1476 // Parameters:
1477 //
1478 // [in ] const VmbHandle_t cameraHandle Handle for a camera
1479 // [in ] const VmbFrame_t* pFrame Frame buffer to be removed from the list of announced frames
1480 //
1481 // Returns:
1482 //
1483 // - VmbErrorSuccess: If no error
1484 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1485 // - VmbErrorBadHandle: The given camera handle is not valid
1486 // - VmbErrorBadParameter: The given frame pointer is not valid
1487 // - VmbErrorStructSize: The given struct size is not valid for this version of the API
1488 //
1489 // Details: The referenced frame is removed from the pool of frames for capturing images.
1490 //
1491 IMEXPORTC VmbError_t VMB_CALL VmbFrameRevoke ( const VmbHandle_t cameraHandle,
1492  const VmbFrame_t* pFrame );
1493 
1494 
1495 //
1496 // Method: VmbFrameRevokeAll()
1497 //
1498 // Purpose: Revoke all frames assigned to a certain camera.
1499 //
1500 // Parameters:
1501 //
1502 // [in ] const VmbHandle_t cameraHandle Handle for a camera
1503 //
1504 // Returns:
1505 //
1506 // - VmbErrorSuccess: If no error
1507 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1508 // - VmbErrorBadHandle: The given camera handle is not valid
1509 //
1510 IMEXPORTC VmbError_t VMB_CALL VmbFrameRevokeAll ( const VmbHandle_t cameraHandle );
1511 
1512 
1513 //
1514 // Method: VmbCaptureStart()
1515 //
1516 // Purpose: Prepare the API for incoming frames.
1517 //
1518 // Parameters:
1519 //
1520 // [in ] const VmbHandle_t cameraHandle Handle for a camera
1521 //
1522 // Returns:
1523 //
1524 // - VmbErrorSuccess: If no error
1525 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1526 // - VmbErrorBadHandle: The given handle is not valid
1527 // - VmbErrorDeviceNotOpen: Camera was not opened for usage
1528 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1529 //
1530 IMEXPORTC VmbError_t VMB_CALL VmbCaptureStart ( const VmbHandle_t cameraHandle );
1531 
1532 
1533 //
1534 // Method: VmbCaptureEnd()
1535 //
1536 // Purpose: Stop the API from being able to receive frames.
1537 //
1538 // Parameters:
1539 //
1540 // [in ] const VmbHandle_t cameraHandle Handle for a camera
1541 //
1542 // Returns:
1543 //
1544 // - VmbErrorSuccess: If no error
1545 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1546 // - VmbErrorBadHandle: The given handle is not valid
1547 //
1548 // Details: Consequences of VmbCaptureEnd():
1549 // - The input queue is flushed
1550 // - The frame callback will not be called any more
1551 //
1552 IMEXPORTC VmbError_t VMB_CALL VmbCaptureEnd ( const VmbHandle_t cameraHandle );
1553 
1554 
1555 //
1556 // Method: VmbCaptureFrameQueue()
1557 //
1558 // Purpose: Queue frames that may be filled during frame capturing.
1559 //
1560 // Parameters:
1561 //
1562 // [in ] const VmbHandle_t cameraHandle Handle of the camera
1563 // [in ] const VmbFrame_t* pFrame Pointer to an already announced frame
1564 // [in ] VmbFrameCallback callback Callback to be run when the frame is complete. NULL is Ok.
1565 //
1566 // Returns:
1567 //
1568 // - VmbErrorSuccess: If no error
1569 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1570 // - VmbErrorBadHandle: The given frame is not valid
1571 // - VmbErrorStructSize: The given struct size is not valid for this version of the API
1572 //
1573 // Details: The given frame is put into a queue that will be filled sequentially.
1574 // The order in which the frames are filled is determined by the order in which they are queued.
1575 // If the frame was announced with VmbFrameAnnounce() before, the application
1576 // has to ensure that the frame is also revoked by calling VmbFrameRevoke() or
1577 // VmbFrameRevokeAll() when cleaning up.
1578 //
1579 IMEXPORTC VmbError_t VMB_CALL VmbCaptureFrameQueue ( const VmbHandle_t cameraHandle,
1580  const VmbFrame_t* pFrame,
1581  VmbFrameCallback callback );
1582 
1583 
1584 //
1585 // Method: VmbCaptureFrameWait()
1586 //
1587 // Purpose: Wait for a queued frame to be filled (or dequeued).
1588 //
1589 // Parameters:
1590 //
1591 // [in ] const VmbHandle_t cameraHandle Handle of the camera
1592 // [in ] const VmbFrame_t* pFrame Pointer to an already announced & queued frame
1593 // [in ] VmbUint32_t timeout Timeout (in milliseconds)
1594 //
1595 // Returns:
1596 //
1597 // - VmbErrorSuccess: If no error
1598 // - VmbErrorTimeout: Call timed out
1599 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1600 // - VmbErrorBadHandle: The given handle is not valid
1601 //
1602 //
1603 IMEXPORTC VmbError_t VMB_CALL VmbCaptureFrameWait ( const VmbHandle_t cameraHandle,
1604  const VmbFrame_t* pFrame,
1605  VmbUint32_t timeout);
1606 
1607 
1608 //
1609 // Method: VmbCaptureQueueFlush()
1610 //
1611 // Purpose: Flush the capture queue.
1612 //
1613 // Parameters:
1614 //
1615 // [in ] const VmbHandle_t cameraHandle Handle of the camera to flush
1616 //
1617 // Returns:
1618 //
1619 // - VmbErrorSuccess: If no error
1620 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1621 // - VmbErrorBadHandle: The given handle is not valid
1622 //
1623 // Details: Control of all the currently queued frames will be returned to the user,
1624 // leaving no frames in the input queue.
1625 // After this call, no frame notification will occur until frames are queued again.
1626 //
1627 IMEXPORTC VmbError_t VMB_CALL VmbCaptureQueueFlush ( const VmbHandle_t cameraHandle );
1628 
1629 
1630 //----- Interface Enumeration & Information --------------------------------------
1631 
1632 //
1633 // Method: VmbInterfacesList()
1634 //
1635 // Purpose: List all the interfaces currently visible to VimbaC.
1636 //
1637 // Parameters:
1638 //
1639 // [out] VmbInterfaceInfo_t* pInterfaceInfo Array of VmbInterfaceInfo_t, allocated by the caller.
1640 // The interface list is copied here. May be NULL.
1641 // [in ] VmbUint32_t listLength Number of entries in the caller's pList array
1642 // [out] VmbUint32_t* pNumFound Number of interfaces found (may be more than
1643 // listLength!) returned here.
1644 // [in ] VmbUint32_t sizeofInterfaceInfo Size of one VmbInterfaceInfo_t entry
1645 //
1646 // Returns:
1647 //
1648 // - VmbErrorSuccess: If no error
1649 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1650 // - VmbErrorStructSize: The given struct size is not valid for this API version
1651 // - VmbErrorMoreData: The given list length was insufficient to hold all available entries
1652 // - VmbErrorBadParameter: pNumFound was NULL
1653 //
1654 // Details: All the interfaces known via GenICam TransportLayers are listed by this
1655 // command and filled into the provided array. Interfaces may correspond to
1656 // adapter cards or frame grabber cards or, in the case of FireWire to the
1657 // whole 1394 infrastructure, for instance.
1658 // This function is usually called twice: once with an empty array to query the length
1659 // of the list, and then again with an array of the correct length.
1660 //
1661 IMEXPORTC VmbError_t VMB_CALL VmbInterfacesList ( VmbInterfaceInfo_t* pInterfaceInfo,
1662  VmbUint32_t listLength,
1663  VmbUint32_t* pNumFound,
1664  VmbUint32_t sizeofInterfaceInfo );
1665 
1666 //
1667 // Method: VmbInterfaceOpen()
1668 //
1669 // Purpose: Open an interface handle for feature access.
1670 //
1671 // Parameters:
1672 //
1673 // [in ] const char* idString The ID of the interface to get the handle for
1674 // (returned by VmbInterfacesList())
1675 // [out] VmbHandle_t* pInterfaceHandle The handle for this interface.
1676 //
1677 // Returns:
1678 //
1679 // - VmbErrorSuccess: If no error
1680 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1681 // - VmbErrorNotFound: The designated interface cannot be found
1682 // - VmbErrorBadParameter: pInterfaceHandle was NULL
1683 //
1684 // Details: An interface can be opened if interface-specific control or information
1685 // is required, e.g. the number of devices attached to a specific interface.
1686 // Access is then possible via feature access methods.
1687 //
1688 IMEXPORTC VmbError_t VMB_CALL VmbInterfaceOpen ( const char* idString,
1689  VmbHandle_t* pInterfaceHandle );
1690 
1691 //
1692 // Method: VmbInterfaceClose()
1693 //
1694 // Purpose: Close an interface.
1695 //
1696 // Parameters:
1697 //
1698 // [in ] const VmbHandle_t interfaceHandle The handle of the interface to close.
1699 //
1700 // Returns:
1701 //
1702 // - VmbErrorSuccess: If no error
1703 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1704 // - VmbErrorBadHandle: The given handle is not valid
1705 //
1706 // Details: After configuration of the interface, close it by calling this function.
1707 //
1708 IMEXPORTC VmbError_t VMB_CALL VmbInterfaceClose ( const VmbHandle_t interfaceHandle );
1709 
1710 
1711 //----- Ancillary data --------------------------------------------------------
1712 
1713 //
1714 // Method: VmbAncillaryDataOpen()
1715 //
1716 // Purpose: Get a working handle to allow access to the elements of the ancillary data via feature access.
1717 //
1718 // Parameters:
1719 //
1720 // [in ] VmbFrame_t* pFrame Pointer to a filled frame
1721 // [out] VmbHandle_t* pAncillaryDataHandle Handle to the ancillary data inside the frame
1722 //
1723 // Returns:
1724 //
1725 // - VmbErrorSuccess: If no error
1726 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1727 //
1728 // Details: This function can only succeed if the given frame has been filled by the API.
1729 //
1730 IMEXPORTC VmbError_t VMB_CALL VmbAncillaryDataOpen ( VmbFrame_t* pFrame,
1731  VmbHandle_t* pAncillaryDataHandle );
1732 
1733 //
1734 // Method: VmbAncillaryDataClose()
1735 //
1736 // Purpose: Destroy the working handle to the ancillary data inside a frame.
1737 //
1738 // Parameters:
1739 //
1740 // [in ] VmbHandle_t ancillaryDataHandle Handle to ancillary frame data
1741 //
1742 // Returns:
1743 //
1744 // - VmbErrorSuccess: If no error
1745 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1746 // - VmbErrorBadHandle: The given handle is not valid
1747 //
1748 // Details: After reading the ancillary data and before re-queuing the frame, ancillary data
1749 // must be closed.
1750 //
1751 IMEXPORTC VmbError_t VMB_CALL VmbAncillaryDataClose ( VmbHandle_t ancillaryDataHandle );
1752 
1753 
1754 //----- Memory/Register access --------------------------------------------
1755 //----- Memory/Register access --------------------------------------------
1756 
1757 //
1758 // Method: VmbMemoryRead()
1759 //
1760 // Purpose: Read an array of bytes.
1761 //
1762 // Parameters:
1763 //
1764 // [in ] const VmbHandle_t handle Handle for an entity that allows memory access
1765 // [in ] VmbUint64_t address Address to be used for this read operation
1766 // [in ] VmbUint32_t bufferSize Size of the data buffer to read
1767 // [out] char* dataBuffer Buffer to be filled
1768 // [out] VmbUint32_t* pSizeComplete Size of the data actually read
1769 //
1770 // Returns:
1771 //
1772 // - VmbErrorSuccess: If no error
1773 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1774 // - VmbErrorBadHandle: The given handle is not valid
1775 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1776 //
1777 IMEXPORTC VmbError_t VMB_CALL VmbMemoryRead ( const VmbHandle_t handle,
1778  VmbUint64_t address,
1779  VmbUint32_t bufferSize,
1780  char* dataBuffer,
1781  VmbUint32_t* pSizeComplete );
1782 
1783 //
1784 // Method: VmbMemoryWrite()
1785 //
1786 // Purpose: Write an array of bytes.
1787 //
1788 // Parameters:
1789 //
1790 // [in ] const VmbHandle_t handle Handle for an entity that allows memory access
1791 // [in ] VmbUint64_t address Address to be used for this read operation
1792 // [in ] VmbUint32_t bufferSize Size of the data buffer to write
1793 // [in ] const char* dataBuffer Data to write
1794 // [out] VmbUint32_t* pSizeComplete Number of bytes successfully written; if an
1795 // error occurs this is less than bufferSize
1796 //
1797 // Returns:
1798 //
1799 // - VmbErrorSuccess: If no error
1800 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1801 // - VmbErrorBadHandle: The given handle is not valid
1802 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1803 // - VmbErrorMoreData: Not all data were written; see pSizeComplete value for the number of bytes written
1804 //
1805 IMEXPORTC VmbError_t VMB_CALL VmbMemoryWrite ( const VmbHandle_t handle,
1806  VmbUint64_t address,
1807  VmbUint32_t bufferSize,
1808  const char* dataBuffer,
1809  VmbUint32_t* pSizeComplete );
1810 
1811 //
1812 // Method: VmbRegistersRead()
1813 //
1814 // Purpose: Read an array of registers.
1815 //
1816 // Parameters:
1817 //
1818 // [in ] const VmbHandle_t handle Handle for an entity that allows register access
1819 // [in ] VmbUint32_t readCount Number of registers to be read
1820 // [in ] const VmbUint64_t* pAddressArray Array of addresses to be used for this read operation
1821 // [out] VmbUint64_t* pDataArray Array of registers to be used for this read operation
1822 // [out] VmbUint32_t* pNumCompleteReads Number of reads completed
1823 //
1824 // Returns:
1825 //
1826 // - VmbErrorSuccess: If no error
1827 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1828 // - VmbErrorBadHandle: The given handle is not valid
1829 // - VmbErrorIncomplete: Not all the requested reads could be completed
1830 //
1831 // Details: Two arrays of data must be provided: an array of register addresses and one
1832 // for corresponding values to be read. The registers are read consecutively
1833 // until an error occurs or all registers are written successfully.
1834 //
1835 IMEXPORTC VmbError_t VMB_CALL VmbRegistersRead ( const VmbHandle_t handle,
1836  VmbUint32_t readCount,
1837  const VmbUint64_t* pAddressArray,
1838  VmbUint64_t* pDataArray,
1839  VmbUint32_t* pNumCompleteReads );
1840 
1841 //
1842 // Method: VmbRegistersWrite()
1843 //
1844 // Purpose: Write an array of registers.
1845 //
1846 // Parameters:
1847 //
1848 // [in ] const VmbHandle_t handle Handle for an entity that allows register access
1849 // [in ] VmbUint32_t writeCount Number of registers to be written
1850 // [in ] const VmbUint64_t* pAddressArray Array of addresses to be used for this write operation
1851 // [in ] const VmbUint64_t* pDataArray Array of reads to be used for this write operation
1852 // [out] VmbUint32_t* pNumCompleteWrites Number of writes completed
1853 //
1854 // Returns:
1855 //
1856 // - VmbErrorSuccess: If no error
1857 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1858 // - VmbErrorBadHandle: The given handle is not valid
1859 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1860 // - VmbErrorIncomplete: Not all the requested writes could be completed
1861 //
1862 // Details: Two arrays of data must be provided: an array of register addresses and one with the
1863 // corresponding values to be written to these addresses. The registers are written
1864 // consecutively until an error occurs or all registers are written successfully.
1865 //
1866 IMEXPORTC VmbError_t VMB_CALL VmbRegistersWrite ( const VmbHandle_t handle,
1867  VmbUint32_t writeCount,
1868  const VmbUint64_t* pAddressArray,
1869  const VmbUint64_t* pDataArray,
1870  VmbUint32_t* pNumCompleteWrites );
1871 
1872 //
1873 // enum type for VmbCameraSettingsSave() which determines which feature shall persisted (saved) to XML file.
1874 //
1876 {
1882 
1883 //
1884 // struct type to collect all settings for VmbCameraSettingsSave and VmbCameraSettingsLoad
1885 //
1886 typedef struct
1887 {
1888  VmbFeaturePersist_t persistType;
1892 
1893 //
1894 // Method: VmbCameraSettingsSave()
1895 //
1896 // Purpose: Saves all feature values to XML file.
1897 //
1898 // Parameters:
1899 //
1900 // [in ] const VmbHandle_t handle Handle for an entity that allows register access
1901 // [in ] const char* fileName Name of XML file to save settings
1902 // [in ] VmbFeaturePersistSettings_t* pSettings Settings struct
1903 // [in ] VmbUint32_t sizeofSettings Size of settings struct
1904 //
1905 // Returns:
1906 //
1907 // - VmbErrorSuccess: If no error
1908 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1909 // - VmbErrorBadHandle: The given handle is not valid
1910 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1911 // - VmbErrorBadParameter: if fileName is NULL
1912 //
1913 // Details: Camera must be opened beforehand and function needs corresponding handle.
1914 // With given filename parameter path and name of XML file can be determined.
1915 // Additionally behaviour of function can be set with providing 'persistent struct'.
1916 //
1917 IMEXPORTC VmbError_t VMB_CALL VmbCameraSettingsSave( const VmbHandle_t handle, const char *fileName, VmbFeaturePersistSettings_t *pSettings, VmbUint32_t sizeofSettings );
1918 
1919 //
1920 // Method: VmbCameraSettingsLoad()
1921 //
1922 // Purpose: Load all feature values from XML file to device.
1923 //
1924 // Parameters:
1925 //
1926 // [in ] const VmbHandle_t handle Handle for an entity that allows register access
1927 // [in ] const char* fileName Name of XML file to save settings
1928 // [in ] VmbFeaturePersistSettings_t* pSettings Settings struct
1929 // [in ] VmbUint32_t sizeofSettings Size of settings struct
1930 //
1931 // Returns:
1932 //
1933 // - VmbErrorSuccess: If no error
1934 // - VmbErrorApiNotStarted: VmbStartup() was not called before the current command
1935 // - VmbErrorBadHandle: The given handle is not valid
1936 // - VmbErrorInvalidAccess: Operation is invalid with the current access mode
1937 // - VmbErrorBadParameter: if fileName is NULL
1938 //
1939 // Details: Camera must be opened beforehand and function needs corresponding handle.
1940 // With given filename parameter path and name of XML file can be determined.
1941 // Additionally behaviour of function can be set with providing 'settings struct'.
1942 //
1943 IMEXPORTC VmbError_t VMB_CALL VmbCameraSettingsLoad( const VmbHandle_t handle, const char *fileName, VmbFeaturePersistSettings_t *pSettings, VmbUint32_t sizeofSettings );
1944 
1945 #ifdef __cplusplus
1946 }
1947 #endif
1948 
1949 #endif // VIMBAC_H_INCLUDE_
IMEXPORTC VmbError_t VMB_CALL VmbFeatureCommandRun(const VmbHandle_t handle, const char *name)
const char * displayName
Definition: VimbaC.h:234
VmbUint32_t bufferSize
Definition: VimbaC.h:276
VmbInt32_t VmbError_t
VmbInterface_t interfaceType
Definition: VimbaC.h:139
IMEXPORTC VmbError_t VMB_CALL VmbInterfaceOpen(const char *idString, VmbHandle_t *pInterfaceHandle)
const char * cameraIdString
Definition: VimbaC.h:152
const char * serialString
Definition: VimbaC.h:141
char VmbBool_t
IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntIncrementQuery(const VmbHandle_t handle, const char *name, VmbInt64_t *pValue)
IMEXPORTC VmbError_t VMB_CALL VmbRegistersWrite(const VmbHandle_t handle, VmbUint32_t writeCount, const VmbUint64_t *pAddressArray, const VmbUint64_t *pDataArray, VmbUint32_t *pNumCompleteWrites)
const char * sfncNamespace
Definition: VimbaC.h:221
const char * name
Definition: VimbaC.h:210
VmbUint32_t offsetX
Definition: VimbaC.h:291
IMEXPORTC VmbError_t VMB_CALL VmbCaptureFrameQueue(const VmbHandle_t cameraHandle, const VmbFrame_t *pFrame, VmbFrameCallback callback)
VmbFeatureVisibilityType
Definition: VimbaC.h:181
IMEXPORTC VmbError_t VMB_CALL VmbFeatureStringMaxlengthQuery(const VmbHandle_t handle, const char *name, VmbUint32_t *pMaxLength)
VmbUint32_t VmbAccessMode_t
Definition: VimbaC.h:130
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumEntryGet(const VmbHandle_t handle, const char *featureName, const char *entryName, VmbFeatureEnumEntry_t *pFeatureEnumEntry, VmbUint32_t sizeofFeatureEnumEntry)
long long VmbInt64_t
IMEXPORTC VmbError_t VMB_CALL VmbFeatureStringGet(const VmbHandle_t handle, const char *name, char *buffer, VmbUint32_t bufferSize, VmbUint32_t *pSizeFilled)
VmbFrameFlags_t receiveFlags
Definition: VimbaC.h:282
VmbUint32_t loggingLevel
Definition: VimbaC.h:1890
VmbUint32_t VmbFeatureFlags_t
Definition: VimbaC.h:202
IMEXPORTC VmbError_t VMB_CALL VmbRegistersRead(const VmbHandle_t handle, VmbUint32_t readCount, const VmbUint64_t *pAddressArray, VmbUint64_t *pDataArray, VmbUint32_t *pNumCompleteReads)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureRawSet(const VmbHandle_t handle, const char *name, const char *pBuffer, VmbUint32_t bufferSize)
IMEXPORTC VmbError_t VMB_CALL VmbMemoryRead(const VmbHandle_t handle, VmbUint64_t address, VmbUint32_t bufferSize, char *dataBuffer, VmbUint32_t *pSizeComplete)
IMEXPORTC VmbError_t VMB_CALL VmbCameraClose(const VmbHandle_t cameraHandle)
int VmbInt32_t
VmbUint32_t pollingTime
Definition: VimbaC.h:215
IMEXPORTC VmbError_t VMB_CALL VmbCaptureStart(const VmbHandle_t cameraHandle)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureListAffected(const VmbHandle_t handle, const char *name, VmbFeatureInfo_t *pFeatureInfoList, VmbUint32_t listLength, VmbUint32_t *pNumFound, VmbUint32_t sizeofFeatureInfo)
VmbUint32_t height
Definition: VimbaC.h:290
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumRangeQuery(const VmbHandle_t handle, const char *name, const char **pNameArray, VmbUint32_t arrayLength, VmbUint32_t *pNumFilled)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumAsString(const VmbHandle_t handle, const char *name, VmbInt64_t intValue, const char **pStringValue)
VmbUint32_t maxIterations
Definition: VimbaC.h:1889
const char * tooltip
Definition: VimbaC.h:219
VmbFeatureDataType
Definition: VimbaC.h:164
VmbFeatureFlags_t featureFlags
Definition: VimbaC.h:212
VmbAccessMode_t permittedAccess
Definition: VimbaC.h:156
VmbUint64_t frameID
Definition: VimbaC.h:294
IMEXPORTC VmbError_t VMB_CALL VmbFeatureStringSet(const VmbHandle_t handle, const char *name, const char *value)
VmbBool_t hasAffectedFeatures
Definition: VimbaC.h:223
IMEXPORTC VmbError_t VMB_CALL VmbCaptureFrameWait(const VmbHandle_t cameraHandle, const VmbFrame_t *pFrame, VmbUint32_t timeout)
const char * cameraName
Definition: VimbaC.h:153
IMEXPORTC VmbError_t VMB_CALL VmbCameraSettingsSave(const VmbHandle_t handle, const char *fileName, VmbFeaturePersistSettings_t *pSettings, VmbUint32_t sizeofSettings)
VmbUint32_t ancillarySize
Definition: VimbaC.h:285
void(VMB_CALL * VmbInvalidationCallback)(const VmbHandle_t handle, const char *name, void *pUserContext)
Definition: VimbaC.h:319
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumSet(const VmbHandle_t handle, const char *name, const char *value)
VmbFrameFlagsType
Definition: VimbaC.h:258
static const VmbHandle_t gVimbaHandle
Definition: VimbaC.h:102
VmbUint32_t imageSize
Definition: VimbaC.h:284
IMEXPORTC VmbError_t VMB_CALL VmbFeatureInvalidationRegister(const VmbHandle_t handle, const char *name, VmbInvalidationCallback callback, void *pUserContext)
VmbAccessModeType
Definition: VimbaC.h:122
VmbFeaturePersist_t persistType
Definition: VimbaC.h:1888
IMEXPORTC VmbError_t VMB_CALL VmbFrameRevokeAll(const VmbHandle_t cameraHandle)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntSet(const VmbHandle_t handle, const char *name, VmbInt64_t value)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatIncrementQuery(const VmbHandle_t handle, const char *name, VmbBool_t *hasIncrement, double *pValue)
VmbBool_t isStreamable
Definition: VimbaC.h:222
void * VmbHandle_t
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumIsAvailable(const VmbHandle_t handle, const char *name, const char *value, VmbBool_t *pIsAvailable)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureInvalidationUnregister(const VmbHandle_t handle, const char *name, VmbInvalidationCallback callback)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureRawLengthQuery(const VmbHandle_t handle, const char *name, VmbUint32_t *pLength)
IMEXPORTC VmbError_t VMB_CALL VmbCameraInfoQuery(const char *idString, VmbCameraInfo_t *pInfo, VmbUint32_t sizeofCameraInfo)
IMEXPORTC VmbError_t VMB_CALL VmbVersionQuery(VmbVersionInfo_t *pVersionInfo, VmbUint32_t sizeofVersionInfo)
IMEXPORTC VmbError_t VMB_CALL VmbFrameAnnounce(const VmbHandle_t cameraHandle, const VmbFrame_t *pFrame, VmbUint32_t sizeofFrame)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureAccessQuery(const VmbHandle_t handle, const char *name, VmbBool_t *pIsReadable, VmbBool_t *pIsWriteable)
const char * interfaceIdString
Definition: VimbaC.h:157
struct VmbFeatureInfo VmbFeatureInfo_t
VmbUint32_t VmbFeatureData_t
Definition: VimbaC.h:176
struct VmbFeatureEnumEntry VmbFeatureEnumEntry_t
const char * name
Definition: VimbaC.h:233
IMEXPORTC VmbError_t VMB_CALL VmbFeatureCommandIsDone(const VmbHandle_t handle, const char *name, VmbBool_t *pIsDone)
IMEXPORTC VmbError_t VMB_CALL VmbInterfacesList(VmbInterfaceInfo_t *pInterfaceInfo, VmbUint32_t listLength, VmbUint32_t *pNumFound, VmbUint32_t sizeofInterfaceInfo)
VmbAccessMode_t permittedAccess
Definition: VimbaC.h:142
const char * serialString
Definition: VimbaC.h:155
unsigned long long VmbUint64_t
IMEXPORTC VmbError_t VMB_CALL VmbStartup(void)
VmbFrameStatus_t receiveStatus
Definition: VimbaC.h:281
VmbUint64_t timestamp
Definition: VimbaC.h:295
IMEXPORTC VmbError_t VMB_CALL VmbMemoryWrite(const VmbHandle_t handle, VmbUint64_t address, VmbUint32_t bufferSize, const char *dataBuffer, VmbUint32_t *pSizeComplete)
const char * modelName
Definition: VimbaC.h:154
VmbInt32_t VmbFrameStatus_t
Definition: VimbaC.h:253
IMEXPORTC VmbError_t VMB_CALL VmbAncillaryDataOpen(VmbFrame_t *pFrame, VmbHandle_t *pAncillaryDataHandle)
IMEXPORTC VmbError_t VMB_CALL VmbFrameRevoke(const VmbHandle_t cameraHandle, const VmbFrame_t *pFrame)
const char * sfncNamespace
Definition: VimbaC.h:238
IMEXPORTC VmbError_t VMB_CALL VmbFeatureInfoQuery(const VmbHandle_t handle, const char *name, VmbFeatureInfo_t *pFeatureInfo, VmbUint32_t sizeofFeatureInfo)
VmbBool_t hasSelectedFeatures
Definition: VimbaC.h:224
IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatSet(const VmbHandle_t handle, const char *name, double value)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumAsInt(const VmbHandle_t handle, const char *name, const char *value, VmbInt64_t *pIntVal)
IMEXPORTC VmbError_t VMB_CALL VmbAncillaryDataClose(VmbHandle_t ancillaryDataHandle)
VmbUint32_t VmbPixelFormat_t
VmbInterfaceType
Definition: VimbaC.h:107
IMEXPORTC VmbError_t VMB_CALL VmbFeatureBoolSet(const VmbHandle_t handle, const char *name, VmbBool_t value)
const char * description
Definition: VimbaC.h:220
VmbUint32_t VmbFeaturePersist_t
Definition: VimbaC.h:1881
IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntGet(const VmbHandle_t handle, const char *name, VmbInt64_t *pValue)
VmbFeatureVisibility_t visibility
Definition: VimbaC.h:235
VmbFeaturePersistType
Definition: VimbaC.h:1875
VmbUint32_t width
Definition: VimbaC.h:289
VmbUint32_t VmbFrameFlags_t
Definition: VimbaC.h:266
IMEXPORTC VmbError_t VMB_CALL VmbCameraSettingsLoad(const VmbHandle_t handle, const char *fileName, VmbFeaturePersistSettings_t *pSettings, VmbUint32_t sizeofSettings)
unsigned int VmbUint32_t
IMEXPORTC VmbError_t VMB_CALL VmbFeatureEnumGet(const VmbHandle_t handle, const char *name, const char **pValue)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureBoolGet(const VmbHandle_t handle, const char *name, VmbBool_t *pValue)
IMEXPORTC VmbError_t VMB_CALL VmbInterfaceClose(const VmbHandle_t interfaceHandle)
VmbFeatureVisibility_t visibility
Definition: VimbaC.h:218
const char * interfaceName
Definition: VimbaC.h:140
IMEXPORTC VmbError_t VMB_CALL VmbFeatureIntRangeQuery(const VmbHandle_t handle, const char *name, VmbInt64_t *pMin, VmbInt64_t *pMax)
IMEXPORTC VmbError_t VMB_CALL VmbCamerasList(VmbCameraInfo_t *pCameraInfo, VmbUint32_t listLength, VmbUint32_t *pNumFound, VmbUint32_t sizeofCameraInfo)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatGet(const VmbHandle_t handle, const char *name, double *pValue)
const char * description
Definition: VimbaC.h:237
VmbUint32_t VmbInterface_t
Definition: VimbaC.h:115
const char * representation
Definition: VimbaC.h:217
VmbFeatureFlagsType
Definition: VimbaC.h:194
IMEXPORTC VmbError_t VMB_CALL VmbFeaturesList(const VmbHandle_t handle, VmbFeatureInfo_t *pFeatureInfoList, VmbUint32_t listLength, VmbUint32_t *pNumFound, VmbUint32_t sizeofFeatureInfo)
IMEXPORTC void VMB_CALL VmbShutdown(void)
IMEXPORTC VmbError_t VMB_CALL VmbCameraOpen(const char *idString, VmbAccessMode_t accessMode, VmbHandle_t *pCameraHandle)
IMEXPORTC VmbError_t VMB_CALL VmbFeatureRawGet(const VmbHandle_t handle, const char *name, char *pBuffer, VmbUint32_t bufferSize, VmbUint32_t *pSizeFilled)
void * buffer
Definition: VimbaC.h:275
IMEXPORTC VmbError_t VMB_CALL VmbFeatureListSelected(const VmbHandle_t handle, const char *name, VmbFeatureInfo_t *pFeatureInfoList, VmbUint32_t listLength, VmbUint32_t *pNumFound, VmbUint32_t sizeofFeatureInfo)
VmbPixelFormat_t pixelFormat
Definition: VimbaC.h:287
VmbInt64_t intValue
Definition: VimbaC.h:239
const char * category
Definition: VimbaC.h:213
IMEXPORTC VmbError_t VMB_CALL VmbCaptureEnd(const VmbHandle_t cameraHandle)
const char * interfaceIdString
Definition: VimbaC.h:138
VmbUint32_t offsetY
Definition: VimbaC.h:292
const char * displayName
Definition: VimbaC.h:214
VmbFrameStatusType
Definition: VimbaC.h:246
IMEXPORTC VmbError_t VMB_CALL VmbCaptureQueueFlush(const VmbHandle_t cameraHandle)
const char * tooltip
Definition: VimbaC.h:236
VmbUint32_t VmbFeatureVisibility_t
Definition: VimbaC.h:189
VmbFeatureData_t featureDataType
Definition: VimbaC.h:211
IMEXPORTC VmbError_t VMB_CALL VmbFeatureFloatRangeQuery(const VmbHandle_t handle, const char *name, double *pMin, double *pMax)
const char * unit
Definition: VimbaC.h:216
void(VMB_CALL * VmbFrameCallback)(const VmbHandle_t cameraHandle, VmbFrame_t *pFrame)
Definition: VimbaC.h:332


avt_vimba_camera
Author(s): Miquel Massot , Allied Vision Technologies
autogenerated on Mon Jun 10 2019 12:50:39