345 struct PEAK_PRODUCER_LIBRARY;
349 struct PEAK_SYSTEM_DESCRIPTOR;
357 struct PEAK_INTERFACE_DESCRIPTOR;
361 struct PEAK_INTERFACE;
365 struct PEAK_DEVICE_DESCRIPTOR;
373 struct PEAK_REMOTE_DEVICE;
377 struct PEAK_DATA_STREAM_DESCRIPTOR;
381 struct PEAK_DATA_STREAM;
389 struct PEAK_BUFFER_CHUNK;
393 struct PEAK_BUFFER_PART;
397 struct PEAK_MODULE_DESCRIPTOR;
405 struct PEAK_NODE_MAP;
413 struct PEAK_INTEGER_NODE;
417 struct PEAK_BOOLEAN_NODE;
421 struct PEAK_COMMAND_NODE;
425 struct PEAK_FLOAT_NODE;
429 struct PEAK_STRING_NODE;
433 struct PEAK_REGISTER_NODE;
437 struct PEAK_CATEGORY_NODE;
441 struct PEAK_ENUMERATION_NODE;
445 struct PEAK_ENUMERATION_ENTRY_NODE;
453 struct PEAK_PORT_URL;
457 struct PEAK_EVENT_SUPPORTING_MODULE;
461 struct PEAK_EVENT_CONTROLLER;
469 struct PEAK_FIRMWARE_UPDATER;
473 struct PEAK_FIRMWARE_UPDATE_INFORMATION;
477 struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER;
484 PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface,
void* context);
487 const char* lostInterfaceId,
size_t lostInterfaceIdSize,
void* context);
520 PEAK_BOOL8 Reserved[6];
526 uint8_t Reserved2[20];
531 PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice,
void* context);
537 const char* lostDeviceId,
size_t lostDeviceIdSize,
void* context);
540 PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice,
void* context);
564 const PEAK_DEVICE_INFORMATION_ROLE* changedRoles,
size_t changedRolesSize,
void* context);
571 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, uint32_t estimatedDuration_ms,
577 uint32_t estimatedDuration_ms,
const char* description,
size_t descriptionSize,
void* context);
582 PEAK_FIRMWARE_UPDATE_STEP updateStep,
double progressPercentage,
void* context);
588 PEAK_FIRMWARE_UPDATE_STEP updateStep,
void* context);
597 const char* errorDescription,
size_t errorDescriptionSize,
void* context);
602 #define PEAK_C_API PEAK_PUBLIC PEAK_RETURN_CODE PEAK_CALL_CONV 604 #ifndef PEAK_DYNAMIC_LOADING 708 PEAK_RETURN_CODE* lastErrorCode,
char* lastErrorDescription,
size_t* lastErrorDescriptionSize);
768 const char* ctiPath,
size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
785 PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle,
char* key,
size_t* keySize);
800 PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE* systemDescriptorHandle);
828 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
845 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* key,
size_t* keySize);
864 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
881 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* displayName,
size_t* displayNameSize);
898 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* vendorName,
size_t* vendorNameSize);
915 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* modelName,
size_t* modelNameSize);
932 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* version,
size_t* versionSize);
949 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* tlType,
size_t* tlTypeSize);
966 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* ctiFileName,
size_t* ctiFileNameSize);
983 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* ctiFullPath,
size_t* ctiFullPathSize);
998 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t* gentlVersionMajor);
1013 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t* gentlVersionMinor);
1028 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING* characterEncoding);
1043 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
1058 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE* systemHandle);
1088 PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
1123 PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1156 PEAK_SYSTEM_HANDLE systemHandle,
char* displayName,
size_t* displayNameSize);
1173 PEAK_SYSTEM_HANDLE systemHandle,
char* vendorName,
size_t* vendorNameSize);
1238 PEAK_SYSTEM_HANDLE systemHandle,
char* ctiFileName,
size_t* ctiFileNameSize);
1255 PEAK_SYSTEM_HANDLE systemHandle,
char* ctiFullPath,
size_t* ctiFullPathSize);
1298 PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING* characterEncoding);
1313 PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
1357 PEAK_SYSTEM_HANDLE systemHandle,
size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE* interfaceDescriptorHandle);
1375 PEAK_INTERFACE_FOUND_CALLBACK_HANDLE* callbackHandle);
1389 PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle);
1407 PEAK_INTERFACE_LOST_CALLBACK_HANDLE* callbackHandle);
1421 PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle);
1449 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
1450 PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
1467 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
char* key,
size_t* keySize);
1486 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1503 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
char* displayName,
size_t* displayNameSize);
1520 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
char* tlType,
size_t* tlTypeSize);
1535 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE* systemHandle);
1550 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
1580 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
1615 int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1648 PEAK_INTERFACE_HANDLE interfaceHandle,
char* displayName,
size_t* displayNameSize);
1679 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE* systemHandle);
1723 PEAK_INTERFACE_HANDLE interfaceHandle,
size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE* deviceDescriptorHandle);
1741 PEAK_DEVICE_FOUND_CALLBACK_HANDLE* callbackHandle);
1755 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle);
1775 PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE* callbackHandle);
1789 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle);
1808 PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE* callbackHandle);
1822 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle);
1854 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle);
1886 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle);
1915 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
1932 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* key,
size_t* keySize);
1951 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1968 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* displayName,
size_t* displayNameSize);
1985 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* vendorName,
size_t* vendorNameSize);
2002 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* modelName,
size_t* modelNameSize);
2019 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* version,
size_t* versionSize);
2036 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* tlType,
size_t* tlTypeSize);
2053 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* userDefinedName,
size_t* userDefinedNameSize);
2070 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* serialNumber,
size_t* serialNumberSize);
2085 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS* accessStatus);
2100 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t* timestampTickFrequency);
2115 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8* isOpenable);
2133 PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8* isOpenable);
2149 PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE* deviceHandle);
2164 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
2179 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t* monitoringUpdateInterval_ms);
2193 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms);
2209 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole,
2210 PEAK_BOOL8* isInformationRoleMonitored);
2224 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole);
2238 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole);
2255 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
2271 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
2302 PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
2337 PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
2370 PEAK_DEVICE_HANDLE deviceHandle,
char* displayName,
size_t* displayNameSize);
2387 PEAK_DEVICE_HANDLE deviceHandle,
char* vendorName,
size_t* vendorNameSize);
2452 PEAK_DEVICE_HANDLE deviceHandle,
char* userDefinedName,
size_t* userDefinedNameSize);
2469 PEAK_DEVICE_HANDLE deviceHandle,
char* serialNumber,
size_t* serialNumberSize);
2484 PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS* accessStatus);
2499 PEAK_DEVICE_HANDLE deviceHandle, uint64_t* timestampTickFrequency);
2514 PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
2529 PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE* remoteDeviceHandle);
2560 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE* dataStreamDescriptorHandle);
2588 PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE* moduleHandle);
2603 PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE* deviceHandle);
2619 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle,
2620 PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
2637 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle,
char* key,
size_t* keySize);
2652 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE* deviceHandle);
2667 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE* dataStreamHandle);
2683 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE* moduleHandle);
2698 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
2733 int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
2766 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
char* tlType,
size_t* tlTypeSize);
2781 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersAnnouncedMinRequired);
2796 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersAnnounced);
2811 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersQueued);
2826 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersAwaitDelivery);
2841 PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numBuffersDelivered);
2856 PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numBuffersStarted);
2885 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numChunksPerBufferMax);
2900 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* bufferAlignment);
2929 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8* definesPayloadSize);
2958 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE* deviceHandle);
2989 PEAK_BUFFER_HANDLE* bufferHandle);
3014 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t bufferSize,
void* userPtr, PEAK_BUFFER_HANDLE* bufferHandle);
3031 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle);
3045 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle);
3074 PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE* bufferHandle);
3103 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode);
3126 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode);
3153 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire);
3167 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode);
3209 PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
3228 PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
3301 PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE* payloadType);
3330 PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE* pixelFormatNamespace);
3345 PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS* pixelEndianness);
3430 PEAK_BUFFER_HANDLE bufferHandle,
size_t* deliveredChunkPayloadSize);
3699 PEAK_BUFFER_HANDLE bufferHandle,
size_t index, PEAK_BUFFER_CHUNK_HANDLE* bufferChunkHandle);
3742 PEAK_BUFFER_HANDLE bufferHandle,
size_t index, PEAK_BUFFER_PART_HANDLE* bufferPartHandle);
3800 PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE* bufferHandle);
3833 int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
3918 PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t* formatNamespace);
4003 PEAK_BUFFER_PART_HANDLE bufferPartHandle,
size_t* deliveredImageHeight);
4018 PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE* bufferHandle);
4049 PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle,
char*
id,
size_t* idSize);
4081 PEAK_MODULE_HANDLE moduleHandle,
size_t index, PEAK_NODE_MAP_HANDLE* nodeMapHandle);
4113 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* nodeName,
size_t nodeNameSize, PEAK_BOOL8* hasNode);
4131 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* nodeName,
size_t nodeNameSize, PEAK_NODE_HANDLE* nodeHandle);
4187 PEAK_NODE_MAP_HANDLE nodeMapHandle,
size_t index, PEAK_NODE_HANDLE* nodeHandle);
4203 PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasSupportedChunks);
4220 PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle);
4236 PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8* hasSupportedData);
4272 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* filePath,
size_t filePathSize);
4291 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* filePath,
size_t filePathSize);
4340 PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE* integerNodeHandle);
4356 PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE* booleanNodeHandle);
4372 PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE* commandNodeHandle);
4418 PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE* registerNodeHandle);
4434 PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE* categoryNodeHandle);
4450 PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE* enumerationNodeHandle);
4466 PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
4570 PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isAccessStatusCacheable);
4719 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* invalidatedNodeHandle);
4750 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* invalidatedNodeHandle);
4768 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* invalidatingNodeHandle);
4799 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* invalidatingNodeHandle);
4817 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* selectedNodeHandle);
4848 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* selectedNodeHandle);
4866 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* selectingNodeHandle);
4897 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* selectingNodeHandle);
4915 PEAK_NODE_CHANGED_CALLBACK_HANDLE* callbackHandle);
4929 PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle);
4945 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5005 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE* incrementType);
5022 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t* validValues,
size_t* validValuesSize);
5037 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION* representation);
5069 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t* value);
5099 PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5116 PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8* value);
5146 PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5279 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE* incrementType);
5296 PEAK_FLOAT_NODE_HANDLE floatNodeHandle,
double* validValues,
size_t* validValuesSize);
5311 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION* representation);
5341 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION* displayNotation);
5356 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t* displayPrecision);
5371 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8* hasConstantIncrement);
5388 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy,
double* value);
5449 PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy,
char* value,
size_t* valueSize);
5465 PEAK_STRING_NODE_HANDLE stringNodeHandle,
const char* value,
size_t valueSize);
5481 PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5527 PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t* bytesToRead,
size_t bytesToReadSize);
5544 PEAK_REGISTER_NODE_HANDLE registerNodeHandle,
const uint8_t* bytesToWrite,
size_t bytesToWriteSize);
5560 PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5591 PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle,
size_t index, PEAK_NODE_HANDLE* nodeHandle);
5607 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5624 PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5640 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle);
5658 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
const char* symbolicValue,
size_t symbolicValueSize);
5674 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value);
5692 const char* symbolicValue,
size_t symbolicValueSize,
5693 PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5710 int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5725 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
size_t* numEntries);
5742 PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5758 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5773 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8* isSelfClearing);
5790 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle,
char* symbolicValue,
size_t* symbolicValueSize);
5805 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t* value);
5826 PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
6027 PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t* bytesToRead,
size_t bytesToReadSize);
6047 PEAK_PORT_HANDLE portHandle, uint64_t address,
const uint8_t* bytesToWrite,
size_t bytesToWriteSize);
6099 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
6160 PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t* fileRegisterAddress);
6190 PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t* fileSha1Hash,
size_t* fileSha1HashSize);
6233 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileVersionSubminor);
6248 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileSchemaVersionMajor);
6263 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileSchemaVersionMinor);
6294 PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType,
6295 PEAK_EVENT_CONTROLLER_HANDLE* eventControllerHandle);
6315 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
6330 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
size_t* numEventsInQueue);
6345 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t* numEventsFired);
6360 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
size_t* eventMaxSize);
6375 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
size_t* eventDataMaxSize);
6390 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE* controlledEventType);
6407 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE* eventHandle);
6466 PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
6574 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
const char* gufPath,
size_t gufPathSize);
6592 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
const char* gufPath,
size_t gufPathSize,
6593 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle);
6608 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
size_t* numFirmwareUpdateInformation);
6625 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
size_t index,
6626 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE* firmwareUpdateInformationHandle);
6645 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
6646 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6647 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);
6667 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
6668 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6669 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6670 uint64_t deviceResetDiscoveryTimeout_ms);
6698 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8* isValid);
6715 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* fileName,
size_t* fileNameSize);
6732 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* description,
6733 size_t* descriptionSize);
6750 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* version,
size_t* versionSize);
6767 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* versionExtractionPattern,
6768 size_t* versionExtractionPatternSize);
6783 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6784 PEAK_FIRMWARE_UPDATE_VERSION_STYLE* versionStyle);
6801 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* releaseNotes,
6802 size_t* releaseNotesSize);
6819 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* releaseNotesUrl,
6820 size_t* releaseNotesUrlSize);
6835 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6836 PEAK_FIRMWARE_UPDATE_PERSISTENCE* userSetPersistence);
6851 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6852 PEAK_FIRMWARE_UPDATE_PERSISTENCE* sequencerSetPersistence);
6866 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE* firmwareUpdateProgressObserverHandle);
6883 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6885 PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE* callbackHandle);
6900 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6901 PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle);
6918 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6920 PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE* callbackHandle);
6935 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6936 PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle);
6954 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6971 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6989 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6991 PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE* callbackHandle);
7006 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
7007 PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle);
7024 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
7026 PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE* callbackHandle);
7041 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
7042 PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle);
7059 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
7061 PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE* callbackHandle);
7076 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
7077 PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle);
7090 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);
7102 #endif // !PEAK_DYNAMIC_LOADING PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Asks the given integer node for its increment.
PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Asks the given buffer for its delivered image height.
PEAK_C_API PEAK_DataStream_GetParentDevice(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Asks the given data stream for its parent device.
PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths()
Collects the paths to the CTIs installed on the system.
struct PEAK_FIRMWARE_UPDATER * PEAK_FIRMWARE_UPDATER_HANDLE
Definition: peak_backend.h:471
PEAK_C_API PEAK_Device_GetDisplayName(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Asks the given device for its display name.
Definition: peak_backend.h:111
Definition: peak_backend.h:260
PEAK_ENDIANNESS_t
Definition: peak_backend.h:149
PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Asks the given enumeration entry node whether it is self clearing.
Definition: peak_backend.h:329
PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given interface descriptor to a module descriptor.
PEAK_C_API PEAK_DataStream_RevokeBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Tells the given data stream to revoke the given buffer.
PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Asks the given node for its number of selected nodes.
int32_t PEAK_ACQUISITION_STOP_MODE
Definition: peak_backend.h:45
Definition: peak_backend.h:333
PEAK_C_API PEAK_Buffer_GetPayloadType(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Asks the given buffer for its payload type.
PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Asks the given buffer for its user pointer.
PEAK_C_API PEAK_Device_GetAccessStatus(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Asks the given device for its access status.
PEAK_EVENT_TYPE_t
Definition: peak_backend.h:158
PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given device to a module.
Definition: peak_backend.h:272
PEAK_C_API PEAK_System_GetCTIFullPath(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Asks the given system for its parent CTI's full path.
struct PEAK_PRODUCER_LIBRARY * PEAK_PRODUCER_LIBRARY_HANDLE
Definition: peak_backend.h:347
Definition: peak_backend.h:57
PEAK_C_API PEAK_FloatNode_GetDisplayNotation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Asks the given float node for its display notation.
PEAK_C_API PEAK_System_GetCharacterEncoding(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Asks the given system for its character encoding.
PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Asks the given port for its ID.
Definition: peak_backend.h:40
PEAK_C_API PEAK_System_GetCTIFileName(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Asks the given system for its parent CTI's file name.
PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Asks the given buffer part for its Y offset.
Definition: peak_backend.h:232
PEAK_C_API PEAK_RegisterNode_ToNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given register node to a node.
PEAK_ACQUISITION_STOP_MODE_t
Definition: peak_backend.h:38
Definition: peak_backend.h:322
Definition: peak_backend.h:321
PEAK_C_API PEAK_Device_GetParentInterface(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Asks the given device for its parent interface.
Definition: peak_backend.h:327
PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Asks the given buffer whether it has chunks.
Definition: peak_backend.h:318
int32_t PEAK_NODE_CACHING_MODE
Definition: peak_backend.h:217
PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Asks the given system descriptor for its parent CTI's full path.
PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Asks the given system descriptor for the minor component of its GenTL version.
Definition: peak_backend.h:69
PEAK_BOOL8 IsRemoteDeviceAcquisitionRunning
Definition: peak_backend.h:516
Definition: peak_backend.h:284
PEAK_C_API PEAK_DataStream_AnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, void *buffer, size_t bufferSize, void *userPtr, PEAK_BUFFER_REVOCATION_CALLBACK revocationCallback, void *callbackContext, PEAK_BUFFER_HANDLE *bufferHandle)
Announces the given buffer at the given data stream.
PEAK_C_API PEAK_EnumerationEntryNode_GetValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Asks the given enumeration entry node for its value.
PEAK_INTERFACE_LIST_CHANGED_CALLBACK * PEAK_INTERFACE_LIST_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:495
PEAK_C_API PEAK_CategoryNode_GetSubNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Asks the given category node for the sub node with the given index.
PEAK_C_API PEAK_Buffer_GetInfo(PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given buffer for an information based on a specific command.
PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Unregisters the interface-lost callback with the given handle from the given system.
int32_t PEAK_PORT_URL_SCHEME
Definition: peak_backend.h:312
PEAK_C_API PEAK_Node_FindInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Tells the given node to find an invalidating node with the given name.
Definition: peak_backend.h:71
Definition: peak_backend.h:214
PEAK_C_API PEAK_System_GetParentLibrary(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Asks the given system for its parent library.
PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Asks the given device for its model name.
Definition: peak_backend.h:262
PEAK_C_API PEAK_SystemDescriptor_GetTLType(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Asks the given system descriptor for its TL type.
PEAK_C_API PEAK_FloatNode_GetRepresentation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Asks the given float node for its representation.
PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Asks the given node for its caching mode.
PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Asks the given node whether it is deprecated.
Definition: peak_backend.h:109
PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Asks the given buffer for its height.
const uint64_t PEAK_INFINITE_NUMBER
The constant defining an infinite number of buffers.
Definition: peak_backend.h:340
Definition: peak_backend.h:133
int32_t PEAK_ACQUISITION_START_MODE
Definition: peak_backend.h:35
PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Asks the given buffer part for its X offset.
PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Asks the given integer node for its minimum.
Definition: peak_backend.h:185
PEAK_C_API PEAK_FloatNode_GetIncrementType(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Asks the given float node for its increment type.
Definition: peak_backend.h:138
PEAK_DEVICE_RECONNECT_ERROR_t
Definition: peak_backend.h:497
PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Destroys the given data stream.
PEAK_C_API PEAK_EventController_WaitForEvent(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE *eventHandle)
Tells the given event controller to wait for an event with the given timeout.
PEAK_C_API PEAK_Interface_UnregisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Unregisters the device disconnected callback with the given handle from the given interface...
PEAK_C_API PEAK_BooleanNode_GetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8 *value)
Asks the given boolean node for its value.
PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Asks the given port URL for its file SHA1 hash.
PEAK_C_API PEAK_RegisterNode_Write(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Tells the given register node to write the given bytes.
PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given buffer to a module.
PEAK_C_API PEAK_Node_FindSelectingNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectingNodeHandle)
Tells the given node to find a selecting node with the given name.
PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Asks the given float node for its minimum.
struct PEAK_PORT_URL * PEAK_PORT_URL_HANDLE
Definition: peak_backend.h:455
PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Asks the given device descriptor for its parent interface.
PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Asks the given device descriptor for its vendor name.
PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Asks the given port for its version.
int8_t PEAK_BOOL8
Definition: peak_backend.h:26
Definition: peak_backend.h:50
Definition: peak_backend.h:320
PEAK_C_API PEAK_Library_Close()
Closes the IDS peak genericAPI library and cleans up any resources that are still in use...
PEAK_C_API PEAK_DeviceDescriptor_OpenDevice(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE *deviceHandle)
Opens the device being associated with the given interface descriptor for the given access type...
PEAK_C_API PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t index, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE *firmwareUpdateInformationHandle)
Asks the given firmware updater for the update information with the given index.
PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Asks the given data stream for its number of queued buffers.
PEAK_C_API PEAK_StringNode_GetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, char *value, size_t *valueSize)
Asks the given string node for its value.
PEAK_C_API PEAK_IntegerNode_GetValidValues(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Asks the given integer node for its valid values.
PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Asks the given system descriptor for its character encoding.
PEAK_C_API PEAK_IntegerNode_ToNode(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given integer node to a node.
Definition: peak_backend.h:334
PEAK_C_API PEAK_Interface_RegisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK callback, void *callbackContext, PEAK_DEVICE_FOUND_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a found device at the given interface.
Definition: peak_backend.h:332
int32_t PEAK_DEVICE_INFORMATION_ROLE
Definition: peak_backend.h:146
Definition: peak_backend.h:256
PEAK_C_API PEAK_DataStream_ToModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given data stream to a module.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Asks the given firmware update information for its version style.
PEAK_C_API PEAK_Interface_RegisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LOST_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a lost device at the given interface.
PEAK_C_API PEAK_EnumerationNode_GetNumEntries(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Asks the given enumeration node for its number of entries.
Definition: peak_backend.h:287
PEAK_C_API PEAK_DeviceDescriptor_IsInformationRoleMonitored(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole, PEAK_BOOL8 *isInformationRoleMonitored)
Asks the given device descriptor whether the given information role is monitored. ...
Definition: peak_backend.h:231
PEAK_BUFFER_PART_TYPE_t
Definition: peak_backend.h:48
Definition: peak_backend.h:74
Definition: peak_backend.h:277
Definition: peak_backend.h:72
PEAK_C_API PEAK_Interface_RegisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNETED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a disconnected device that is now waiting to be reconnected at the giv...
PEAK_C_API PEAK_System_RegisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_LOST_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a lost interface at the given system.
PEAK_C_API PEAK_Module_GetNodeMap(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Asks the given module for the node map with the given index.
PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Asks the given interface for its TL type.
PEAK_C_API PEAK_Node_ToEnumerationEntryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Casts the given node to an enumeration entry node.
PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Asks the given port URL for its parent port.
Definition: peak_backend.h:213
struct PEAK_INTERFACE_DESCRIPTOR * PEAK_INTERFACE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:359
void(PEAK_CALL_CONV * PEAK_DEVICE_DISCONNETED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice, void *context)
Definition: peak_backend.h:539
PEAK_C_API PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, uint64_t deviceResetDiscoveryTimeout_ms)
Tells the given firmware updater to update the given device with the given update information...
PEAK_C_API PEAK_DataStream_QueueBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Tells the given data stream to queue the given buffer.
PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Asks the given firmware updater for its number of update information.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a progress change within an update step at the given firmware update p...
PEAK_C_API PEAK_BufferPart_GetParentBuffer(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Asks the given buffer part for its parent buffer.
Definition: peak_backend.h:308
Definition: peak_backend.h:508
PEAK_C_API PEAK_Interface_GetDisplayName(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Asks the given interface for its display name.
PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Destroys the given buffer part.
PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Asks the given device for its key.
PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Asks the given data stream for its number of started buffers.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a finished update at the given firmware update progress observer...
int32_t PEAK_NODE_TYPE
Definition: peak_backend.h:279
PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Asks the given device descriptor for its access status.
Definition: peak_backend.h:181
PEAK_C_API PEAK_IntegerNode_GetIncrementType(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Asks the given integer node for its increment type.
Definition: peak_backend.h:502
PEAK_C_API PEAK_EventController_GetEventMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Asks the event controller for the maximum size of an event.
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Tells the given enumeration node to set its current entry by the given symbolic value.
Definition: peak_backend.h:53
PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Asks the given node whether it is a feature, i.e. it can be reached via category nodes from a categor...
Definition: peak_backend.h:137
Definition: peak_backend.h:270
PEAK_C_API PEAK_System_GetVendorName(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Asks the given system for its vendor name.
PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Asks the given integer node for its unit.
PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Asks the given system descriptor for its parent CTI's file name.
PEAK_PORT_URL_SCHEME_t
Definition: peak_backend.h:304
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Tells the given enumeration node to set its current entry to the given entry.
struct PEAK_INTEGER_NODE * PEAK_INTEGER_NODE_HANDLE
Definition: peak_backend.h:415
Definition: peak_backend.h:307
struct PEAK_EVENT_SUPPORTING_MODULE * PEAK_EVENT_SUPPORTING_MODULE_HANDLE
Definition: peak_backend.h:459
Definition: peak_backend.h:41
void(PEAK_CALL_CONV * PEAK_DEVICE_FOUND_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void *context)
Definition: peak_backend.h:530
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle)
Unregisters the update started callback with the given handle from the given firmware update progress...
PEAK_NODE_NAMESPACE_t
Definition: peak_backend.h:246
PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Asks the given port for its model name.
PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Asks the given buffer for its timestamp in nanoseconds.
Definition: peak_backend.h:310
PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Asks the given data stream for its number of announced buffers.
PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Asks the given node whether it is streamable.
PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Asks the given buffer for its chunk layout ID.
PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Asks the given node for its polling time.
Definition: peak_backend.h:261
struct PEAK_CATEGORY_NODE * PEAK_CATEGORY_NODE_HANDLE
Definition: peak_backend.h:439
PEAK_C_API PEAK_Interface_GetInfo(PEAK_INTERFACE_HANDLE interfaceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given interface for an information based on a specific command.
Definition: peak_backend.h:323
PEAK_C_API PEAK_ProducerLibrary_GetSystem(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Asks the given producer library for its system descriptor.
PEAK_NODE_DISPLAY_NOTATION_t
Definition: peak_backend.h:228
PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Asks the given interface for its key.
int32_t PEAK_NODE_INCREMENT_TYPE
Definition: peak_backend.h:243
PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Tells the given data stream to kill a wait for a finished buffer.
PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Asks the given integer node for its maximum.
PEAK_C_API PEAK_DeviceDescriptor_GetVersion(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Asks the given device descriptor for its version.
int32_t PEAK_NODE_VISIBILITY
Definition: peak_backend.h:289
PEAK_C_API PEAK_Node_FindInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Tells the given node to find an invalidated node with the given name.
Definition: peak_backend.h:55
Definition: peak_backend.h:113
PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Opens the interface being associated with the given interface descriptor.
PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Asks the given node map for its number of nodes.
PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Asks the given buffer for its pixel format namespace.
PEAK_C_API PEAK_Node_ToRegisterNode(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Casts the given node to a register node.
PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t *numCtiPaths)
Asks for the number of CTI paths.
PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Asks the given node for its number of selecting nodes.
Definition: peak_backend.h:33
PEAK_C_API PEAK_SystemDescriptor_GetInfo(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given system descriptor for an information based on a specific command.
Definition: peak_backend.h:184
PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Asks the given buffer for its expected data size.
PEAK_C_API PEAK_Node_ToCommandNode(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Casts the given node to a command node.
struct PEAK_EVENT_CONTROLLER * PEAK_EVENT_CONTROLLER_HANDLE
Definition: peak_backend.h:463
Definition: peak_backend.h:112
PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Tells the given node map to poll its nodes.
Definition: peak_backend.h:223
PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given interface to a module.
int32_t PEAK_RETURN_CODE
Definition: peak_backend.h:337
Definition: peak_backend.h:43
PEAK_C_API PEAK_DeviceDescriptor_GetTLType(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Asks the given device descriptor for its TL type.
PEAK_C_API PEAK_Device_GetInfo(PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given device for an information based on a specific command.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Asks the given firmware update information for its release notes.
PEAK_C_API PEAK_Device_GetUserDefinedName(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Asks the given device for its user-defined name.
PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Asks the given category node for its number of sub nodes.
PEAK_C_API PEAK_SystemDescriptor_GetVersion(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Asks the given system descriptor for its version.
PEAK_NODE_CACHE_USE_POLICY_t
Definition: peak_backend.h:220
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the update step progress changed callback with the given handle from the given firmware u...
PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Asks the given system for its TL type.
void(PEAK_CALL_CONV * PEAK_INTERFACE_FOUND_CALLBACK)(PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface, void *context)
Definition: peak_backend.h:483
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Creates a firmware update progress observer.
Definition: peak_backend.h:296
PEAK_C_API PEAK_EnumerationNode_ToNode(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given enumeration node to a node.
PEAK_NODE_REPRESENTATION_t
Definition: peak_backend.h:254
PEAK_C_API PEAK_DataStreamDescriptor_GetKey(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Asks the given data stream descriptor for its key.
PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Asks the given register node for its length.
PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Asks the given system descriptor for its parent library.
Definition: peak_backend.h:139
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void *context)
Definition: peak_backend.h:581
PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Asks the given buffer for its delivered chunk payload size.
PEAK_C_API PEAK_DataStream_AllocAndAnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t bufferSize, void *userPtr, PEAK_BUFFER_HANDLE *bufferHandle)
Tells the given data stream to allocate and announce a buffer with the given size.
PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Waits (blocking) until the previously executed command is finished, i.e. PEAK_CommandNode_GetIsDone()...
Definition: peak_backend.h:164
PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Asks the given data stream whether it is grabbing.
PEAK_BOOL8 IsRemoteDeviceConfigurationRestored
Definition: peak_backend.h:518
struct PEAK_NODE * PEAK_NODE_HANDLE
Definition: peak_backend.h:411
Definition: peak_backend.h:31
PEAK_C_API PEAK_Node_FindSelectedNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectedNodeHandle)
Tells the given node to find a selected node with the given name.
PEAK_C_API PEAK_Buffer_GetPart(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Asks the given buffer for the part with the given index.
PEAK_C_API PEAK_Node_RegisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK callback, void *callbackContext, PEAK_NODE_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a change at the given node.
PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Asks the given device for its version.
Definition: peak_backend.h:54
PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Asks the given remote device for its local device.
Definition: peak_backend.h:153
PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Tells the given event controller to flush all events in queue.
PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given system descriptor to a module descriptor.
Definition: peak_backend.h:70
PEAK_C_API PEAK_Library_GetLastError(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Queries the last error.
PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Asks the given event for its type.
PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Destroys the given firmware updater.
PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Asks the given interface descriptor for its display name.
PEAK_C_API PEAK_ProducerLibrary_GetKey(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Asks the given producer library for its key.
int32_t PEAK_NODE_DISPLAY_NOTATION
Definition: peak_backend.h:234
PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Asks the given port URL for the major component of its file schema version.
PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Asks the given buffer for its timestamp in ticks.
Definition: peak_backend.h:142
PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Updates event information in the node map.
PEAK_C_API PEAK_Node_GetSelectingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Asks the given node for the selecting node with the given index.
Definition: peak_backend.h:110
Definition: peak_backend.h:202
Definition: peak_backend.h:80
int32_t PEAK_NODE_NAMESPACE
Definition: peak_backend.h:251
PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Asks the given firmware update information for its description.
PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Asks the given node for its number of invalidated nodes.
Definition: peak_backend.h:326
PEAK_C_API PEAK_System_RegisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a found interface at the given system.
Definition: peak_backend.h:95
PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE
Definition: peak_backend.h:594
Definition: peak_backend.h:52
PEAK_DEVICE_DISCONNETED_CALLBACK * PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE
Definition: peak_backend.h:548
PEAK_C_API PEAK_PortURL_GetInfo(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given port URL for an information based on a specific command.
PEAK_C_API PEAK_DataStream_WaitForFinishedBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE *bufferHandle)
Tells the given data stream to wait for a finished buffer with the given timeout. ...
int32_t PEAK_CHARACTER_ENCODING
Definition: peak_backend.h:90
PEAK_C_API PEAK_EventSupportingModule_EnableEvents(PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType, PEAK_EVENT_CONTROLLER_HANDLE *eventControllerHandle)
Tells the given event-supporting module to enable events of the given type.
PEAK_DEVICE_LIST_CHANGED_CALLBACK * PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:552
PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Asks the given float node for its maximum.
int32_t PEAK_DEVICE_ACCESS_TYPE
Definition: peak_backend.h:128
PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Asks the given node for its namespace.
PEAK_DEVICE_ACCESS_STATUS_t
Definition: peak_backend.h:106
Definition: peak_backend.h:134
int32_t PEAK_DATA_STREAM_FLUSH_MODE
Definition: peak_backend.h:103
PEAK_C_API PEAK_ProducerLibrary_Construct(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Creates a producer library.
int32_t PEAK_ENDIANNESS
Definition: peak_backend.h:155
Definition: peak_backend.h:162
Definition: peak_backend.h:77
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a failed update at the given firmware update progress observer...
PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Tells the given boolean node to set the given value.
PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Asks the given port URL for its scheme.
Definition: peak_backend.h:136
PEAK_NODE_INCREMENT_TYPE_t
Definition: peak_backend.h:237
int32_t PEAK_EVENT_TYPE
Definition: peak_backend.h:168
PEAK_C_API PEAK_Node_ToEnumerationNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Casts the given node to an enumeration node.
PEAK_C_API PEAK_DataStream_GetTLType(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Asks the given data stream for its TL type.
struct PEAK_NODE_MAP * PEAK_NODE_MAP_HANDLE
Definition: peak_backend.h:407
PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Asks the given buffer part for its height.
PEAK_C_API PEAK_SystemDescriptor_OpenSystem(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Opens the system being associated with the given system descriptor.
PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Unregisters the interface-found callback with the given handle from the given system.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Asks the given firmware update information for its file name.
PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Checks if the buffer contains chunks corresponding to the node map.
PEAK_FIRMWARE_UPDATE_PERSISTENCE_t
Definition: peak_backend.h:171
PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Asks the given data stream for its number of delivered buffers.
Definition: peak_backend.h:324
PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Asks the given system for its key.
struct PEAK_MODULE_DESCRIPTOR * PEAK_MODULE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:399
PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Asks the given node for its display name.
struct PEAK_ENUMERATION_ENTRY_NODE * PEAK_ENUMERATION_ENTRY_NODE_HANDLE
Definition: peak_backend.h:447
PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Asks the given port for the URL with the given index.
PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Asks the given port for its number of URLs.
PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given system to a module.
Definition: peak_backend.h:286
PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Asks the given buffer chunk for its base pointer.
PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Asks the given buffer for its Y offset.
PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given device descriptor to a module descriptor.
PEAK_C_API PEAK_DataStream_Flush(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Tells the given data stream to flush its queues using the given mode.
Definition: peak_backend.h:51
PEAK_C_API PEAK_Device_GetRemoteDevice(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Asks the given device for its remote device.
PEAK_DEVICE_FOUND_CALLBACK * PEAK_DEVICE_FOUND_CALLBACK_HANDLE
Definition: peak_backend.h:544
PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Asks the given interface descriptor for its TL type.
PEAK_C_API PEAK_Port_Write(PEAK_PORT_HANDLE portHandle, uint64_t address, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Tells the given port to write the given amount of bytes at the given address.
Definition: peak_backend.h:135
PEAK_C_API PEAK_BufferChunk_GetParentBuffer(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Asks the given buffer chunk for its parent buffer.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Asks the given firmware update information for its version extraction pattern.
PEAK_C_API PEAK_NodeMap_LoadFromFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Tells the given node map to load the values of its streamable nodes from a file at the given file pat...
PEAK_C_API PEAK_Interface_GetDevice(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Asks the given interface for the device descriptor with the given index.
PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Asks the given node for its number of invalidating nodes.
struct PEAK_REMOTE_DEVICE * PEAK_REMOTE_DEVICE_HANDLE
Definition: peak_backend.h:375
PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Unregisters the device-found callback with the given handle from the given interface.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Asks the given firmware update information whether it is valid.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle)
Unregisters the update step finished callback with the given handle from the given firmware update pr...
int32_t PEAK_BUFFER_PART_TYPE
Definition: peak_backend.h:63
PEAK_C_API PEAK_EventController_GetInfo(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given event controller for an information based on a specific command.
Definition: peak_backend.h:203
Definition: peak_backend.h:274
PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Asks the given port URL for the major component of its file version.
PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Asks the given buffer for its X padding.
PEAK_C_API PEAK_DeviceDescriptor_GetModelName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Asks the given device descriptor for its model name.
PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Asks the given device descriptor whether the device can be opened with exclusive access.
PEAK_C_API PEAK_Node_ToIntegerNode(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Casts the given node to an integer node.
struct PEAK_ENUMERATION_NODE * PEAK_ENUMERATION_NODE_HANDLE
Definition: peak_backend.h:443
Definition: peak_backend.h:259
Definition: peak_backend.h:230
Definition: peak_backend.h:174
PEAK_C_API PEAK_DataStream_StartAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire)
Tells the given data stream to start the acquisition using the given mode and to acquire the given nu...
PEAK_C_API PEAK_BooleanNode_ToNode(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given boolean node to a node.
PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Asks the given buffer for its file name.
Definition: peak_backend.h:88
PEAK_RETURN_CODE_t
Definition: peak_backend.h:315
PEAK_C_API PEAK_SystemDescriptor_GetVendorName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Asks the given system descriptor for its vendor name.
PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Asks the given event for its ID.
Definition: peak_backend.h:186
Definition: peak_backend.h:141
PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Asks the given port whether it is readable.
PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Asks the given buffer whether it has new data since the last delivery.
PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle)
Delete the given device.
Definition: peak_backend.h:151
PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Asks the given buffer for its number of parts.
PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Tells the given integer node to set the given value.
PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Tells the given device descriptor to add the given information role to the monitoring.
Definition: peak_backend.h:99
PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Asks the given buffer whether it is queued.
Definition: peak_backend.h:330
Definition: peak_backend.h:206
Definition: peak_backend.h:123
void(PEAK_CALL_CONV * PEAK_INTERFACE_LIST_CHANGED_CALLBACK)(void *context)
Definition: peak_backend.h:489
PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8 *isInitialized)
Checks if the IDS peak genericAPI library is initialized.
Definition: peak_backend.h:144
void(PEAK_CALL_CONV * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK)(const PEAK_DEVICE_INFORMATION_ROLE *changedRoles, size_t changedRolesSize, void *context)
Definition: peak_backend.h:563
Definition: peak_backend.h:275
PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Asks the given event for its data.
PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Asks the given buffer for its delivered data size.
PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Asks the given port URL for the minor component of its file schema version.
PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Asks the given data stream for its ID.
PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given string node to a node.
PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Asks for the subminor component of the library version.
PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given data stream descriptor to a module descriptor.
PEAK_FIRMWARE_UPDATE_STEP_t
Definition: peak_backend.h:179
PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Asks the given buffer for its image offset.
Definition: peak_backend.h:108
PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Locks a recursive mutex on the NodeMap.
Definition: peak_backend.h:58
struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER * PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE
Definition: peak_backend.h:479
PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Asks the given data stream for its key.
struct PEAK_EVENT * PEAK_EVENT_HANDLE
Definition: peak_backend.h:467
PEAK_FIRMWARE_UPDATE_VERSION_STYLE_t
Definition: peak_backend.h:192
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, uint32_t estimatedDuration_ms, const char *description, size_t descriptionSize, void *context)
Definition: peak_backend.h:576
PEAK_C_API PEAK_BufferPart_GetFormatNamespace(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Asks the given buffer part for its format namespace.
struct PEAK_BUFFER * PEAK_BUFFER_HANDLE
Definition: peak_backend.h:387
PEAK_DEVICE_INFORMATION_ROLE_t
Definition: peak_backend.h:131
Definition: peak_backend.h:241
PEAK_C_API PEAK_SystemDescriptor_GetKey(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Asks the given system descriptor for its key.
PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Destroys the given buffer chunk.
PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Asks the given device descriptor for its display name.
Definition: peak_backend.h:271
PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Asks the given buffer part for its delivered image height.
struct PEAK_BOOLEAN_NODE * PEAK_BOOLEAN_NODE_HANDLE
Definition: peak_backend.h:419
PEAK_C_API PEAK_Buffer_ToEventSupportingModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given buffer to an event-supporting module.
PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Asks the given node for its type.
Definition: peak_backend.h:183
PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Asks the given device for its ID.
Definition: peak_backend.h:59
PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Destroys the given event controller.
PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Asks the given system for the minor component of its GenTL version.
PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Waits (blocking) without timeout until the previously executed command is finished, i.e. PEAK_CommandNode_GetIsDone() returns true.
Definition: peak_backend.h:328
Definition: peak_backend.h:317
PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Asks the given device for its number of data streams.
Definition: peak_backend.h:325
PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Tells the given interface to update its devices with the given timeout.
PEAK_C_API PEAK_System_GetDisplayName(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Asks the given system for its display name.
Definition: peak_backend.h:78
PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE
Definition: peak_backend.h:579
Definition: peak_backend.h:124
PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Asks the given float node whether it has a constant increment.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a started update at the given firmware update progress observer...
PEAK_C_API PEAK_Port_Read(PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t *bytesToRead, size_t bytesToReadSize)
Tells the given port to read the given amount of bytes at the given address.
Definition: peak_backend.h:248
PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Tells the given float node to set the given value.
PEAK_C_API PEAK_StringNode_SetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Tells the given string node to set the given value.
Definition: peak_backend.h:56
PEAK_C_API PEAK_Interface_UnregisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the device-list-changed callback with the given handle from the given interface...
PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Asks the given port for its data endianness.
PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given float node to a node.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void *context)
Definition: peak_backend.h:592
struct PEAK_STRING_NODE * PEAK_STRING_NODE_HANDLE
Definition: peak_backend.h:431
PEAK_C_API PEAK_DeviceDescriptor_RegisterInformationChangedCallback(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling changed information at the given device descriptor.
int32_t PEAK_NODE_ACCESS_STATUS
Definition: peak_backend.h:208
PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle)
Tells the given buffer to update its parts.
PEAK_DATA_STREAM_FLUSH_MODE_t
Definition: peak_backend.h:93
PEAK_C_API PEAK_Device_GetSerialNumber(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Asks the given device for its serial number.
PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Asks the given float node for its display precision.
PEAK_C_API PEAK_System_GetInfo(PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given system for an information based on a specific command.
PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle)
Destroys the given event.
Definition: peak_backend.h:269
PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Asks the given data stream for its number of buffers awaiting delivery.
void(PEAK_CALL_CONV * PEAK_INTERFACE_LOST_CALLBACK)(const char *lostInterfaceId, size_t lostInterfaceIdSize, void *context)
Definition: peak_backend.h:486
PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Asks the given data stream for its minimum required number of announced buffers.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a started update step at the given firmware update progress observer...
Definition: peak_backend.h:273
Definition: peak_backend.h:96
void(PEAK_CALL_CONV * PEAK_DEVICE_RECONNECTED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE reconnectedDevice, PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void *context)
Definition: peak_backend.h:533
PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Asks the given system for the major component of its GenTL version.
PEAK_NODE_CHANGED_CALLBACK * PEAK_NODE_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:560
PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Asks the given buffer part for its size.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle)
Unregisters the update finished callback with the given handle from the given firmware update progres...
PEAK_ACQUISITION_START_MODE_t
Definition: peak_backend.h:29
PEAK_C_API PEAK_NodeMap_GetNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Asks the given node map for the node with the given index.
PEAK_C_API PEAK_Device_GetTimestampTickFrequency(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Asks the given device for its timestamp tick frequency.
PEAK_DEVICE_RECONNECT_ERROR_FLAGS ErrorFlags
Definition: peak_backend.h:523
Definition: peak_backend.h:239
PEAK_C_API PEAK_DataStream_StopAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Tells the given data stream to stop the acquisition using the given mode.
PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Asks the given buffer for its base pointer.
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Tells the given enumeration node to set its current entry by the given value.
PEAK_C_API PEAK_NodeMap_GetHasNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_BOOL8 *hasNode)
Checks whether the given node map contains a node with the given name.
PEAK_C_API PEAK_Interface_ToEventSupportingModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given interface to an event-supporting module.
PEAK_C_API PEAK_Interface_RegisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a reconnected device at the given interface.
PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Asks the given device descriptor for its serial number.
PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Asks the given system descriptor for the major component of its GenTL version.
struct PEAK_FLOAT_NODE * PEAK_FLOAT_NODE_HANDLE
Definition: peak_backend.h:427
PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE
Definition: peak_backend.h:590
#define PEAK_C_API
Definition: peak_backend.h:602
PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Asks the given data stream descriptor for its parent device.
PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Asks the given node for its visibility.
PEAK_C_API PEAK_System_ToEventSupportingModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given system to an event-supporting module.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Asks the given firmware update information for its release notes URL.
PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Asks the given port URL for the subminor component of its file version.
PEAK_C_API PEAK_IntegerNode_GetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t *value)
Asks the given integer node for its value.
PEAK_NODE_VISIBILITY_t
Definition: peak_backend.h:282
Definition: peak_backend.h:161
PEAK_C_API PEAK_DataStream_GetInfo(PEAK_DATA_STREAM_HANDLE dataStreamHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given data stream for an information based on a specific command.
Definition: peak_backend.h:173
PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Asks the given node for its access status.
Definition: peak_backend.h:222
PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Updates chunk information in the node map.
Definition: peak_backend.h:294
PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Asks the given firmware update information for its user set persistence.
PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle)
Destroys the given interface.
PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char *ctiPath, size_t *ctiPathSize)
Asks for the CTI path with the given index.
struct PEAK_SYSTEM * PEAK_SYSTEM_HANDLE
Definition: peak_backend.h:355
PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Asks the given buffer whether it is acquiring.
void(PEAK_CALL_CONV * PEAK_DEVICE_LOST_CALLBACK)(const char *lostDeviceId, size_t lostDeviceIdSize, void *context)
Definition: peak_backend.h:536
Definition: peak_backend.h:295
PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenable(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8 *isOpenable)
Asks the given device descriptor whether the device can be opened with this specific access type...
PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Asks the given node for its parent node map.
PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Asks the given buffer for its X offset.
struct PEAK_SYSTEM_DESCRIPTOR * PEAK_SYSTEM_DESCRIPTOR_HANDLE
Definition: peak_backend.h:351
PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Asks the given buffer part for its format.
PEAK_C_API PEAK_Node_GetInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Asks the given node for the invalidating node with the given index.
PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Asks the given device descriptor for its timestamp tick frequency.
PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Tells the given data stream to start the acquisition using the given mode.
PEAK_C_API PEAK_RegisterNode_Read(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t *bytesToRead, size_t bytesToReadSize)
Tells the given register node to read the given amount of bytes.
PEAK_C_API PEAK_DeviceDescriptor_GetInfo(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given device descriptor for an information based on a specific command.
PEAK_DEVICE_RECONNECTED_CALLBACK * PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE
Definition: peak_backend.h:546
PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Asks the given node for its name.
struct PEAK_DATA_STREAM * PEAK_DATA_STREAM_HANDLE
Definition: peak_backend.h:383
Definition: peak_backend.h:299
Definition: peak_backend.h:319
PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Creates a firmware updater.
PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Asks for the minor component of the library version.
PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Asks the given module for its number of node maps.
PEAK_C_API PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the information changed callback with the given handle from the given device descriptor...
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Destroys the given firmware update progress observer.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, uint32_t estimatedDuration_ms, void *context)
Definition: peak_backend.h:570
PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Asks the given float node for its increment.
PEAK_C_API PEAK_EventController_GetEventDataMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Asks the event controller for the maximum size of an event's data.
PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle)
Tells the given buffer to update its chunks.
PEAK_C_API PEAK_FloatNode_GetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double *value)
Asks the given float node for its value.
PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Asks the given system descriptor for its display name.
uint32_t PEAK_DEVICE_RECONNECT_ERROR_FLAGS
Definition: peak_backend.h:510
struct PEAK_DEVICE_DESCRIPTOR * PEAK_DEVICE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:367
struct PEAK_PORT * PEAK_PORT_HANDLE
Definition: peak_backend.h:451
PEAK_C_API PEAK_EnumerationNode_GetEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t index, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Asks the given enumeration node for the entry with the given index.
PEAK_C_API PEAK_FirmwareUpdater_UpdateDevice(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Tells the given firmware updater to update the given device with the given update information...
PEAK_C_API PEAK_DataStream_GetBufferAlignment(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Asks the given data stream for its buffer alignment.
PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Asks the given buffer for its number of chunks.
PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Destroys the given producer library.
Definition: peak_backend.h:204
PEAK_C_API PEAK_EnumerationEntryNode_ToNode(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given enumeration entry node to a node.
Definition: peak_backend.h:115
PEAK_C_API PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle)
Tells the given firmware updater to collect all update information fitting to the given device...
Definition: peak_backend.h:297
PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Asks the given buffer whether it is has an image.
PEAK_PIXEL_FORMAT_NAMESPACE_t
Definition: peak_backend.h:292
Definition: peak_backend.h:76
#define PEAK_CALL_CONV
Definition: peak_dynamic_loader.h:29
PEAK_C_API PEAK_NodeMap_StoreToFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Tells the given node map to store the values of its streamable nodes to a file at the given file path...
PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Tells the given device descriptor to remove the given information role from the monitoring.
Definition: peak_backend.h:101
PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Asks the given data stream for its payload size.
PEAK_C_API PEAK_System_GetInterface(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Asks the given system for the interface descriptor with the given index.
Definition: peak_backend.h:182
Definition: peak_backend.h:205
PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Asks the given port for its name.
PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Asks the given register node for its address.
PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Asks the given port URL for its file size.
PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Asks the given buffer part for its type.
PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Asks the given module for its port.
PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Asks the given buffer part for its base pointer.
PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:567
PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Unlocks the recursive mutex on the NodeMap.
PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Asks the given port whether it is implemented.
Definition: peak_backend.h:276
PEAK_C_API PEAK_FloatNode_GetValidValues(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Asks the given float node for its valid values.
Definition: peak_backend.h:73
PEAK_C_API PEAK_Interface_RegisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a change in the device list at the given interface.
PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Casts the given node to a float node.
PEAK_C_API PEAK_EventController_GetNumEventsInQueue(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Asks the event controller for its number of events in queue.
PEAK_C_API PEAK_Node_ToBooleanNode(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Casts the given node to a boolean node.
int32_t PEAK_FIRMWARE_UPDATE_STEP
Definition: peak_backend.h:189
int32_t PEAK_BUFFER_PAYLOAD_TYPE
Definition: peak_backend.h:82
int32_t PEAK_NODE_CACHE_USE_POLICY
Definition: peak_backend.h:225
Definition: peak_backend.h:306
Definition: peak_backend.h:152
PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Asks the given interface for its number of devices.
PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Asks the given system for its version.
PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Asks the given port for its vendor name.
PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Asks the given port URL for its URL string.
Definition: peak_backend.h:98
int32_t PEAK_DEVICE_ACCESS_STATUS
Definition: peak_backend.h:117
PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Asks the given device descriptor for its user-defined name.
PEAK_C_API PEAK_Interface_GetParentSystem(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Asks the given interface for its parent system.
struct PEAK_INTERFACE * PEAK_INTERFACE_HANDLE
Definition: peak_backend.h:363
PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Tells the given node map to invalidate its nodes.
PEAK_C_API PEAK_EnumerationNode_FindEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Tells the given enumeration node to find a entry with the given symbolic value.
PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Asks the given data stream for its maximum number of chunks per buffer.
PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Asks the given enumeration entry node for its symbolic value.
PEAK_C_API PEAK_EnumerationNode_GetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Asks the given enumeration node for its current entry.
Definition: peak_backend.h:215
PEAK_C_API PEAK_BufferPart_GetInfo(PEAK_BUFFER_PART_HANDLE bufferPartHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given buffer part for an information based on a specific command.
PEAK_C_API PEAK_RemoteDevice_ToModule(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given remote device to a module.
Definition: peak_backend.h:126
PEAK_C_API PEAK_Port_GetInfo(PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given port for an information based on a specific command.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, void *context)
Definition: peak_backend.h:587
PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Tells the given device descriptor to set the given monitoring update interval.
Definition: peak_backend.h:506
int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE
Definition: peak_backend.h:176
PEAK_C_API PEAK_InterfaceDescriptor_GetKey(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Asks the given interface descriptor for its key.
PEAK_C_API PEAK_Device_ToEventSupportingModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given device to an event-supporting module.
PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Asks the given port URL for the minor component of its file version.
PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Asks the given system for its ID.
PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Tells the given firmware updater to collect all update information from the .guf file.
Definition: peak_backend.h:285
PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Asks the given port URL for its file register address.
PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Asks the given device for its TL type.
PEAK_C_API PEAK_Node_GetSelectedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Asks the given node for the selected node with the given index.
PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Asks the given data stream for its number of underruns.
PEAK_NODE_TYPE_t
Definition: peak_backend.h:267
int32_t PEAK_PIXEL_FORMAT_NAMESPACE
Definition: peak_backend.h:301
PEAK_C_API PEAK_IntegerNode_GetRepresentation(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Asks the given integer node for its representation.
PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Asks the given interface descriptor for its parent system.
PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Asks the given buffer for its TL type.
struct PEAK_BUFFER_CHUNK * PEAK_BUFFER_CHUNK_HANDLE
Definition: peak_backend.h:391
Definition: peak_backend.h:87
PEAK_C_API PEAK_Interface_UnregisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Unregisters the device-reconnected callback with the given handle from the given interface.
Definition: peak_backend.h:61
PEAK_C_API PEAK_CategoryNode_ToNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given category node to a node.
PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Asks the given buffer for its pixel format.
Definition: peak_backend.h:257
Definition: peak_backend.h:140
PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Asks the given command node whether its associated command is done.
struct PEAK_FIRMWARE_UPDATE_INFORMATION * PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE
Definition: peak_backend.h:475
PEAK_C_API PEAK_SystemDescriptor_GetModelName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Asks the given system descriptor for its model name.
Definition: peak_backend.h:194
PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Asks the given buffer whether it is incomplete.
PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Checks if the event contains data corresponding to the node map.
void(PEAK_CALL_CONV * PEAK_BUFFER_REVOCATION_CALLBACK)(void *buffer, void *userPtr, void *context)
Definition: peak_backend.h:555
void(PEAK_CALL_CONV * PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void *context)
Definition: peak_backend.h:558
PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE
Definition: peak_backend.h:574
struct PEAK_MODULE * PEAK_MODULE_HANDLE
Definition: peak_backend.h:403
PEAK_C_API PEAK_ModuleDescriptor_GetID(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Asks the given module descriptor for its ID.
PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle)
Destroys the given system.
PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Asks the given buffer for its size.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Asks the given firmware update information for its sequencer set persistence.
PEAK_C_API PEAK_EventController_GetNumEventsFired(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Asks the event controller for its number of fired events.
PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Unregisters the device-lost callback with the given handle from the given interface.
PEAK_C_API PEAK_Device_GetDataStream(PEAK_DEVICE_HANDLE deviceHandle, size_t index, PEAK_DATA_STREAM_DESCRIPTOR_HANDLE *dataStreamDescriptorHandle)
Asks the given device for the data stream descriptor with the given index.
PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Asks the given buffer part for its source ID.
PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Asks the given node for its description.
PEAK_C_API PEAK_InterfaceDescriptor_GetInfo(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given interface descriptor for an information based on a specific command.
PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Asks the given device descriptor for its monitoring update interval.
PEAK_DEVICE_LOST_CALLBACK * PEAK_DEVICE_LOST_CALLBACK_HANDLE
Definition: peak_backend.h:550
Definition: peak_backend.h:68
PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Asks the given node for its tooltip.
Definition: peak_backend.h:97
struct PEAK_DEVICE * PEAK_DEVICE_HANDLE
Definition: peak_backend.h:371
struct PEAK_COMMAND_NODE * PEAK_COMMAND_NODE_HANDLE
Definition: peak_backend.h:423
PEAK_C_API PEAK_DataStream_ToEventSupportingModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given data stream to an event-supporting module.
Definition: peak_backend.h:258
PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Asks the given buffer for its width.
PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Asks the given node whether its access status is cacheable.
PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Asks the given system for its number of interfaces.
PEAK_C_API PEAK_Device_GetVendorName(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Asks the given device for its vendor name.
PEAK_C_API PEAK_NodeMap_FindNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE *nodeHandle)
Tells the given node map to find a node with the given name.
PEAK_C_API PEAK_EnumerationNode_FindEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Tells the given enumeration node to find a entry with the given value.
PEAK_C_API PEAK_EventController_GetControlledEventType(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Asks the event controller for its controlled event type.
PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Asks the given float node for its unit.
void(PEAK_CALL_CONV * PEAK_DEVICE_LIST_CHANGED_CALLBACK)(void *context)
Definition: peak_backend.h:542
PEAK_NODE_ACCESS_STATUS_t
Definition: peak_backend.h:200
Definition: peak_backend.h:160
PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Asks the given buffer chunk for its ID.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle)
Unregisters the update failed callback with the given handle from the given firmware update progress ...
PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Asks the given buffer part for its width.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(const char *errorDescription, size_t errorDescriptionSize, void *context)
Definition: peak_backend.h:596
PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Asks the given port whether it is available.
PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Asks the given port whether it is writable.
PEAK_NODE_CACHING_MODE_t
Definition: peak_backend.h:211
PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Asks for the major component of the library version.
PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Asks the given event for its raw data.
PEAK_C_API PEAK_Library_Initialize()
Initializes the IDS peak genericAPI library.
PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Asks the given buffer for its frame ID.
int32_t PEAK_NODE_REPRESENTATION
Definition: peak_backend.h:264
struct PEAK_DATA_STREAM_DESCRIPTOR * PEAK_DATA_STREAM_DESCRIPTOR_HANDLE
Definition: peak_backend.h:379
Definition: peak_backend.h:195
Definition: peak_backend.h:240
Definition: peak_backend.h:166
Definition: peak_backend.h:331
Definition: peak_backend.h:249
PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Asks the given buffer for its Y padding.
PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Asks the given port URL for its file name.
PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Asks the given string node for its maximum length.
PEAK_INTERFACE_LOST_CALLBACK * PEAK_INTERFACE_LOST_CALLBACK_HANDLE
Definition: peak_backend.h:493
PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Tells the given event controller to kill a wait for an event.
PEAK_INTERFACE_FOUND_CALLBACK * PEAK_INTERFACE_FOUND_CALLBACK_HANDLE
Definition: peak_backend.h:491
PEAK_C_API PEAK_Buffer_GetChunk(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Asks the given buffer for the chunk with the given index.
PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Opens the data stream being associated with the given data stream descriptor.
PEAK_C_API PEAK_DeviceDescriptor_GetKey(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Asks the given device descriptor for its key.
PEAK_DEVICE_ACCESS_TYPE_t
Definition: peak_backend.h:120
PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Asks the given data stream whether it defines the payload size.
PEAK_C_API PEAK_Event_GetInfo(PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given event for an information based on a specific command.
PEAK_C_API PEAK_Node_ToCategoryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Casts the given node to a category node.
PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Asks the given interface for its ID.
int32_t PEAK_FIRMWARE_UPDATE_VERSION_STYLE
Definition: peak_backend.h:197
PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Tells the given system to update its interfaces with the given timeout.
struct PEAK_BUFFER_PART * PEAK_BUFFER_PART_HANDLE
Definition: peak_backend.h:395
PEAK_C_API PEAK_Node_UnregisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the changed callback with the given handle from the given node.
PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Asks the given port for its module name.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a finished update step at the given firmware update progress observer...
struct PEAK_REGISTER_NODE * PEAK_REGISTER_NODE_HANDLE
Definition: peak_backend.h:435
PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:585
PEAK_BUFFER_PAYLOAD_TYPE_t
Definition: peak_backend.h:66
Definition: peak_backend.h:187
PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Asks the given buffer part for its X padding.
Definition: peak_backend.h:513
Definition: peak_backend.h:163
PEAK_C_API PEAK_Node_GetInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Asks the given node for the invalidated node with the given index.
PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Asks the given node whether it is cacheable.
const uint64_t PEAK_INFINITE_TIMEOUT
Definition: peak_backend.h:343
PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Asks the given port for its TL type.
PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Asks the given system for its model name.
PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Casts the given node to a string node.
PEAK_C_API PEAK_Buffer_GetPixelEndianness(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Asks the given buffer for its pixel endianness.
PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Tells the given command node to execute its associated command.
PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Asks the given buffer chunk for its size.
PEAK_C_API PEAK_CommandNode_ToNode(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given command node to a node.
PEAK_CHARACTER_ENCODING_t
Definition: peak_backend.h:85
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle)
Unregisters the update step started callback with the given handle from the given firmware update pro...
PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE
Definition: peak_backend.h:599
Definition: peak_backend.h:122
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Asks the given firmware update information for its version.
Definition: peak_backend.h:75
Definition: peak_backend.h:500
